const __vite__fileDeps = [
    "assets/AxArtboardUploadsDesktopTracker-Dyru3eYS.js",
    "assets/vendor-BOsc3Pjv.js",
    "assets/index-Dr7F7vam.js",
    "assets/index-CDO1T3Qd.css",
    "assets/AxWorkspacesMigrationDialog-B1D44buS.js",
    "assets/AxInputSearch-CBMtdAab.js",
    "assets/AxInputSearch-DhZZXicd.css",
    "assets/AxWorkspacesMigrationDialog-BAoySNg9.css",
    "assets/AxInstallingSketchPluginNotification-6xN0FKo3.js",
    "assets/AxProgressSpinner-BVOHowrq.js",
    "assets/AxProgressSpinner-CXHou5pt.css",
    "assets/AxBadgeNotifications-giH4WeDD.js",
  ],
  __vite__mapDeps = (i) => i.map((i) => __vite__fileDeps[i]);
var ee = Object.defineProperty;
var te = (t, e, s) =>
  e in t
    ? ee(t, e, { enumerable: !0, configurable: !0, writable: !0, value: s })
    : (t[e] = s);
var C = (t, e, s) => te(t, typeof e != "symbol" ? e + "" : e, s);
import {
  n,
  A as se,
  p as y,
  r as re,
  e as L,
  u as I,
  N as ie,
  a as oe,
  b as ne,
  U as ae,
  R as de,
  c as ue,
  d as le,
  f as ce,
  g as pe,
  D as T,
  h as me,
  i as f,
  j as w,
  k as he,
  l as fe,
  m as W,
  o as U,
  q as ge,
  s as xe,
  t as h,
  v as u,
  w as x,
  x as we,
  _,
  y as v,
  z as be,
  B as ve,
  C as Ae,
  E as ye,
  F as _e,
  G as $,
  H as Fe,
  I as Ce,
  J as ke,
  K as Se,
  M as Pe,
  L as Ie,
  O as Ue,
  P as $e,
  Q as Be,
  S as Re,
  T as Oe,
  V as je,
  W as d,
  X as B,
  Y as De,
  Z as Ne,
  $ as Ee,
  a0 as Me,
  a1 as Le,
  a2 as Te,
  a3 as V,
  a4 as We,
  a5 as z,
  a6 as Ve,
  a7 as ze,
  a8 as qe,
  a9 as m,
  aa as Je,
  ab as g,
  ac as He,
  ad as Ge,
  ae as F,
  af as A,
  ag as l,
  ah as Qe,
  ai as p,
  aj as q,
  ak as J,
  al as H,
  am as G,
  an as Ke,
  ao as Xe,
  ap as Ye,
  aq as Ze,
  ar as R,
  as as et,
  at as Q,
  au as K,
  av as tt,
  aw as b,
  ax as st,
  ay as rt,
  az as it,
} from "./index-Dr7F7vam.js";
import {
  V as o,
  P as ot,
  U as nt,
  W as at,
  u as dt,
  s as ut,
} from "./vendor-BOsc3Pjv.js";
import { A as lt, S as O } from "./AxInputSearch-CBMtdAab.js";
const ct = o.extend({
  computed: {
    isFullScreen() {
      const { desktop: t } = this.$store.state;
      return t.desktopParams.isFullScreen;
    },
  },
});
var pt = function () {
    var e = this,
      s = e._self._c;
    return (
      e._self._setupProxy,
      s(
        "div",
        { staticClass: "wrapper", class: { "full-screen": e.isFullScreen } },
        [
          s("header", [e._t("header")], 2),
          s("div", { staticClass: "main" }, [e._t("default")], 2),
          s("footer", [e._t("footer")], 2),
        ]
      )
    );
  },
  mt = [],
  ht = n(ct, pt, mt, !1, null, "8bb24b7f", null, null);
const ft = ht.exports,
  gt = o.extend({
    data() {
      return { dragging: !1 };
    },
    methods: {
      handleDragStart(t) {
        this.$emit("drag-start", t);
      },
      handleDragEnd(t) {
        (this.dragging = !1), this.$emit("drag-end", t);
      },
      handleDragEnter(t) {
        (this.dragging = !0), this.$emit("drag-enter", t);
      },
      handleDragOver(t) {
        this.dragging = !0;
        let e;
        if (t.dataTransfer) {
          try {
            e = t.dataTransfer.effectAllowed;
          } catch {}
          t.dataTransfer.dropEffect =
            e === "move" || e === "linkMove" ? "move" : "copy";
        }
        this.$emit("drag-over", t);
      },
      handleDragLeave(t) {
        (this.dragging = !1), this.$emit("drag-leave", t);
      },
      handleDrop(t) {
        if (((this.dragging = !1), !t.dataTransfer)) return;
        const e = Array.from(t.dataTransfer.files);
        this.$emit("drop", e, t);
      },
    },
  });
var xt = function () {
    var e = this,
      s = e._self._c;
    return (
      e._self._setupProxy,
      s(
        "div",
        {
          on: {
            dragstart: e.handleDragStart,
            dragend: e.handleDragEnd,
            dragenter: function (r) {
              return (
                r.preventDefault(),
                r.stopPropagation(),
                e.handleDragEnter.apply(null, arguments)
              );
            },
            dragover: function (r) {
              return (
                r.preventDefault(),
                r.stopPropagation(),
                e.handleDragOver.apply(null, arguments)
              );
            },
            dragleave: e.handleDragLeave,
            drop: function (r) {
              return (
                r.preventDefault(),
                r.stopPropagation(),
                e.handleDrop.apply(null, arguments)
              );
            },
          },
        },
        [e._t("default", null, { dragging: e.dragging })],
        2
      )
    );
  },
  wt = [],
  bt = n(gt, xt, wt, !1, null, null, null, null);
const vt = bt.exports,
  At = o.extend({
    components: { AxUpload: se },
    props: {
      project: y({ required: !0 }),
      markedUploadArea: { type: Boolean, default: !1 },
    },
    data() {
      const t = this.$store.state,
        { axShareConfig: e } = t;
      return {
        files: {},
        filesInProgress: {},
        batchId: "",
        options: {
          uploadAreaClasses: `asset-uploader-upload-area ${
            this.markedUploadArea ? "asset-uploader-upload-area-marked" : ""
          }`,
          acceptedFileTypes: ["image/*"],
          driverOptions: {
            url: `${re(e)}/expo/addartboard/${this.project.shortcut}`,
            paramName: "fileData",
            withCredentials: !0,
            params: { skipPublishNote: !0 },
          },
          autoProcessQueue: !1,
          uploadMultiple: !0,
          clickable: !1,
          disableDraggable: !0,
          maxFileSize: 5 * 1024 * 1024,
          maxConcurrentUploads: 20,
        },
      };
    },
    computed: {
      hasFiles() {
        return (
          Object.keys(this.files).length > 0 ||
          Object.keys(this.filesInProgress).length > 0
        );
      },
      uploaderClasses() {
        return ["asset-uploader-v-transmit"];
      },
      disableUpload() {
        return this.$store.getters.enterpriseLicenseCheckFailed;
      },
      disableUploadMessage() {
        return L;
      },
    },
    methods: {
      triggerBrowse() {
        const t = this.$refs.uploader;
        t && t.triggerBrowseFiles();
      },
      addFile(t) {
        const e = this.$refs.uploader;
        e && e.addFile(t);
      },
      acceptedFile(t) {
        const e = I();
        o.set(this.files, e, t),
          this.$emit("files-added"),
          (!this.batchId ||
            this.$store.getters.batchUploadCompletedOrDismissed(
              this.batchId
            )) &&
            ((this.batchId = I()),
            this.$store.commit(
              new ie({
                batchId: this.batchId,
                shortcut: this.project.shortcut,
                projectName: this.project.name,
                source: oe.Web,
              })
            ));
        const s = () =>
          new Promise((r) => {
            this.cancelUpload(t),
              this.$store.commit(
                new me({
                  shortcut: this.project.shortcut,
                  batchId: this.batchId,
                  artboardId: e,
                })
              ),
              r();
          });
        this.$store.commit(
          new ne({
            shortcut: this.project.shortcut,
            batchId: this.batchId,
            artboardId: e,
            artboardName: t.nativeFile.name,
            cancel: s,
          })
        );
      },
      uploadProgress(t, e) {
        const s = this.getArtboardId(t);
        if (!s) {
          console.warn("Upload In Progress not found.");
          return;
        }
        this.$store.commit(
          new ae({
            shortcut: this.project.shortcut,
            batchId: this.batchId,
            artboardId: s,
            progress: e,
          })
        );
      },
      cancelUpload(t) {
        const e = this.$refs.uploader;
        e && e.cancelUpload(t);
      },
      removeFileById(t) {
        const e = this.files[t];
        return e ? this.removeFile(e) : !1;
      },
      removeFile(t) {
        const e = this.getArtboardId(t);
        if (e) {
          const s = this.$refs.uploader;
          return (
            s && s.cancelUpload(t),
            o.delete(this.files, e),
            o.delete(this.filesInProgress, e),
            this.$store.commit(new de(this.batchId, e)),
            !0
          );
        }
        return !1;
      },
      onFileRemoved(t) {
        this.removeFile(t) && (this.hasFiles || this.$emit("files-removed"));
      },
      async successSingle(t, e, s) {
        const r = this.getArtboardId(t);
        if (!e.success) {
          this.error(t, e.message);
          return;
        }
        if (!r) {
          console.warn("Upload In Progress not found.");
          return;
        }
        const i = e.data;
        for (let a = 0; a < i.urls.length; a++) {
          const c = i.artboards[a],
            Y = i.assets[a],
            Z = i.urls[a];
          await this.$store.dispatch(new ue(this.project.shortcut, c, Y, Z)),
            this.$store.commit(
              new le({
                shortcut: this.project.shortcut,
                batchId: this.batchId,
                artboardId: r,
                serverArtboardId: c.Id,
              })
            );
        }
      },
      queueComplete() {
        this.$emit("queue-complete");
      },
      error(t, e) {
        (t.status = ce.Error),
          (t.errorMessage = `Unable to upload file ${t.name}: ${e}`);
        const s = this.getArtboardId(t);
        s &&
          this.$store.commit(
            new pe({
              shortcut: this.project.shortcut,
              batchId: this.batchId,
              artboardId: s,
              errorMessage: e,
            })
          );
      },
      getArtboardId(t) {
        const e = Object.entries(this.files),
          s = Object.entries(this.filesInProgress),
          i = [...e, ...s].find(([a, c]) => c === t);
        if (i) return i[0];
      },
      processFiles() {
        const t = this.$refs.uploader;
        if (!t) return;
        (this.filesInProgress = this.files), (this.files = {});
        const e = Object.values(this.filesInProgress);
        for (const s of e) this.uploadProgress(s, 0);
        t.processFiles(e);
      },
      clear() {
        (this.files = {}),
          this.batchId && this.$store.commit(new T(this.batchId));
      },
    },
  });
var yt = function () {
    var e = this,
      s = e._self._c;
    return (
      e._self._setupProxy,
      s(
        "div",
        { staticClass: "asset-uploader" },
        [
          e.disableUpload
            ? s(
                "p",
                { staticClass: "text-danger text-center align-self-center" },
                [e._v(" " + e._s(e.disableUploadMessage) + " ")]
              )
            : s(
                "AxUpload",
                e._b(
                  {
                    ref: "uploader",
                    class: e.uploaderClasses,
                    on: {
                      "accepted-file": e.acceptedFile,
                      "removed-file": e.onFileRemoved,
                      success: e.successSingle,
                      "queue-complete": e.queueComplete,
                      error: e.error,
                      "upload-progress": e.uploadProgress,
                    },
                  },
                  "AxUpload",
                  e.options,
                  !1
                )
              ),
        ],
        1
      )
    );
  },
  _t = [],
  Ft = n(At, yt, _t, !1, null, "186b865e", null, null);
const Ct = Ft.exports,
  kt = o.extend({
    components: {
      AxDropzone: vt,
      AxIcon: f,
      AssetUploader: Ct,
      AxButton: w,
      AxPublishNotes: he,
      Portal: ot,
    },
    data() {
      return {
        activatedKey: 0,
        close: fe,
        AnalyticsClickEvents: W,
        publishNote: void 0,
        uploading: {},
      };
    },
    computed: {
      disableUpload() {
        return this.$store.getters.enterpriseLicenseCheckFailed;
      },
      disableUploadMessage() {
        return L;
      },
      batches() {
        const { uploads: t } = this.$store.state;
        return Object.values(t.batches).filter(Boolean);
      },
      batchesInProgress() {
        return this.$store.getters.batchesInProgress;
      },
      currentProject() {
        const { node: t } = this.$store.getters.current;
        if (U(t)) return t;
      },
      projects() {
        const { batchesInProgress: t, currentProject: e } = this,
          s = [];
        e && s.push(e);
        for (const r of t) {
          if (e && r.shortcut === e.shortcut) continue;
          const i = this.$store.getters.getFsNode(r.shortcut);
          U(i) && s.push(i);
        }
        return s;
      },
      queuedFiles() {
        const t = this.getAssetUploader();
        if (t) {
          const e = t.batchId;
          return this.$store.getters.batchNotStartedArtboards(e);
        }
        return [];
      },
      hasFiles() {
        return this.queuedFiles.length > 0;
      },
      currentUserId() {
        const { user: t } = this.$store.state;
        return t.userInfo ? t.userInfo.userId : "";
      },
      currentUserToken() {
        const { accountService: t } = this.$store.state;
        return t ? t().AuthToken : "";
      },
      shortcut() {
        if (this.currentProject) return this.currentProject.shortcut;
      },
    },
    activated() {
      const t = this.getAssetUploader();
      t && typeof t.clear == "function" && t.clear();
    },
    methods: {
      getAssetUploader() {
        if (this.currentProject) {
          const t = this.$refs[`assetUploader_${this.currentProject.shortcut}`];
          if (Array.isArray(t)) return t[0];
        }
      },
      triggerBrowse(t) {
        if (this.currentProject) {
          t && (this.close = t);
          const e = this.getAssetUploader();
          e && typeof e.triggerBrowse == "function" && e.triggerBrowse();
        }
      },
      addFiles(t) {
        const e = this.getAssetUploader();
        e &&
          typeof e.addFile == "function" &&
          ge(t, (s) => s.name).map(e.addFile);
      },
      async uploadAssets() {
        if (!this.currentProject) return;
        const t = this.currentProject.id;
        try {
          o.set(this.uploading, t, !0), await this.$nextTick();
          const e = this.getAssetUploader();
          e &&
            typeof e.processFiles == "function" &&
            (await xe(
              t,
              this.publishNote ? JSON.stringify(this.publishNote) : ""
            ),
            (this.publishNote = void 0),
            this.activatedKey++,
            e.processFiles()),
            this.close && this.close();
        } finally {
          o.set(this.uploading, t, !1);
        }
      },
      removeFile(t) {
        const e = this.getAssetUploader();
        e && typeof e.removeFileById == "function" && e.removeFileById(t.id);
      },
      filesAdded(t) {
        o.set(this.uploading, t, !1);
      },
      isUploading(t) {
        return !!this.uploading[t];
      },
    },
  });
var St = function () {
    var e = this,
      s = e._self._c;
    return (
      e._self._setupProxy,
      s(
        "div",
        [
          s("Portal", {
            attrs: { to: "asset-uploader" },
            scopedSlots: e._u([
              {
                key: "default",
                fn: function (r) {
                  return [
                    s(
                      "div",
                      {
                        staticClass: "asset-uploader-section",
                        class: { "has-files": e.hasFiles },
                        attrs: { tabindex: "-1" },
                        on: {
                          keydown: function (i) {
                            return !i.type.indexOf("key") &&
                              e._k(i.keyCode, "esc", 27, i.key, [
                                "Esc",
                                "Escape",
                              ])
                              ? null
                              : r.deactivate.apply(null, arguments);
                          },
                        },
                      },
                      [
                        r.showClose
                          ? s(
                              "div",
                              { staticClass: "asset-uploader-close" },
                              [
                                s(
                                  "AxButton",
                                  {
                                    attrs: { color: "link" },
                                    on: { click: r.deactivate },
                                  },
                                  [
                                    s("AxIcon", {
                                      attrs: {
                                        name: "add",
                                        size: "auto",
                                        rotate: "45deg",
                                      },
                                    }),
                                  ],
                                  1
                                ),
                              ],
                              1
                            )
                          : e._e(),
                        e.disableUpload
                          ? s(
                              "p",
                              {
                                staticClass:
                                  "text-danger text-center align-self-center mt-auto mb-auto",
                              },
                              [e._v(" " + e._s(e.disableUploadMessage) + " ")]
                            )
                          : [
                              s("AxDropzone", {
                                on: { drop: e.addFiles },
                                scopedSlots: e._u(
                                  [
                                    {
                                      key: "default",
                                      fn: function ({ dragging: i }) {
                                        return [
                                          s(
                                            "div",
                                            {
                                              staticClass:
                                                "asset-uploader-zone",
                                              class: {
                                                "asset-uploader-zone--is-dragging":
                                                  i,
                                              },
                                            },
                                            [
                                              e.hasFiles
                                                ? s(
                                                    "div",
                                                    {
                                                      staticClass:
                                                        "ax-asset-items",
                                                    },
                                                    e._l(
                                                      e.queuedFiles,
                                                      function (a) {
                                                        return s(
                                                          "div",
                                                          {
                                                            key: a.id,
                                                            staticClass:
                                                              "ax-asset-item row g-0",
                                                          },
                                                          [
                                                            s("AxIcon", {
                                                              staticClass:
                                                                "col-auto ax-asset-icon",
                                                              attrs: {
                                                                name: "images",
                                                              },
                                                            }),
                                                            s(
                                                              "span",
                                                              {
                                                                staticClass:
                                                                  "ax-file-name col",
                                                              },
                                                              [
                                                                e._v(
                                                                  " " +
                                                                    e._s(
                                                                      a.name
                                                                    ) +
                                                                    " "
                                                                ),
                                                              ]
                                                            ),
                                                            s(
                                                              "AxButton",
                                                              {
                                                                staticClass:
                                                                  "col-auto ax-asset-close",
                                                                attrs: {
                                                                  color: "link",
                                                                  tabindex:
                                                                    "-1",
                                                                },
                                                                on: {
                                                                  click:
                                                                    function (
                                                                      c
                                                                    ) {
                                                                      return e.removeFile(
                                                                        a
                                                                      );
                                                                    },
                                                                },
                                                              },
                                                              [
                                                                s("AxIcon", {
                                                                  attrs: {
                                                                    name: "close",
                                                                  },
                                                                }),
                                                              ],
                                                              1
                                                            ),
                                                          ],
                                                          1
                                                        );
                                                      }
                                                    ),
                                                    0
                                                  )
                                                : s(
                                                    "div",
                                                    [
                                                      s(
                                                        "h5",
                                                        {
                                                          staticClass:
                                                            "text-body-secondary",
                                                        },
                                                        [
                                                          e._v(
                                                            " 在此处拖放图像或 "
                                                          ),
                                                        ]
                                                      ),
                                                      s(
                                                        "AxButton",
                                                        {
                                                          attrs: {
                                                            color: "secondary",
                                                            medium: "",
                                                          },
                                                          on: {
                                                            click: () =>
                                                              e.triggerBrowse(
                                                                r.deactivate
                                                              ),
                                                          },
                                                        },
                                                        [e._v(" 选择文件 ")]
                                                      ),
                                                      s(
                                                        "p",
                                                        {
                                                          staticClass:
                                                            "asset-uploader-label asset-uploader-label-extensions",
                                                        },
                                                        [
                                                          e._v(
                                                            " .png, .jpg, .gif, .svg and more "
                                                          ),
                                                        ]
                                                      ),
                                                    ],
                                                    1
                                                  ),
                                            ]
                                          ),
                                        ];
                                      },
                                    },
                                  ],
                                  null,
                                  !0
                                ),
                              }),
                              e.hasFiles
                                ? [
                                    e.shortcut
                                      ? s(
                                          "div",
                                          { staticClass: "uploader-info-row" },
                                          [
                                            s(
                                              "span",
                                              {
                                                staticClass:
                                                  "uploader-notes-title",
                                              },
                                              [e._v(" Publish Notes ")]
                                            ),
                                            s("AxPublishNotes", {
                                              key: e.activatedKey,
                                              attrs: {
                                                shortcut: e.shortcut,
                                                "user-id": e.currentUserId,
                                                "user-token":
                                                  e.currentUserToken,
                                                autofocus: "",
                                              },
                                              model: {
                                                value: e.publishNote,
                                                callback: function (i) {
                                                  e.publishNote = i;
                                                },
                                                expression: "publishNote",
                                              },
                                            }),
                                          ],
                                          1
                                        )
                                      : e._e(),
                                    s(
                                      "div",
                                      { staticClass: "upload-buttons-row" },
                                      [
                                        s(
                                          "AxButton",
                                          {
                                            staticClass: "add-files-button",
                                            attrs: { color: "link", large: "" },
                                            on: {
                                              click: () =>
                                                e.triggerBrowse(r.deactivate),
                                            },
                                          },
                                          [e._v(" Add Files ")]
                                        ),
                                        s(
                                          "AxButton",
                                          {
                                            staticClass: "upload-files-button",
                                            attrs: {
                                              type: "submit",
                                              color: "upload",
                                              loading:
                                                !!e.currentProject &&
                                                e.isUploading(
                                                  e.currentProject.id
                                                ),
                                            },
                                            on: {
                                              click: function (i) {
                                                return (
                                                  i.preventDefault(),
                                                  e.uploadAssets.apply(
                                                    null,
                                                    arguments
                                                  )
                                                );
                                              },
                                            },
                                          },
                                          [e._v(" Upload ")]
                                        ),
                                      ],
                                      1
                                    ),
                                  ]
                                : e._e(),
                            ],
                      ],
                      2
                    ),
                  ];
                },
              },
            ]),
          }),
          s(
            "div",
            {
              directives: [
                {
                  name: "show",
                  rawName: "v-show",
                  value: !1,
                  expression: "false",
                },
              ],
            },
            e._l(e.projects, function (r) {
              return s("AssetUploader", {
                key: r.shortcut,
                ref: `assetUploader_${r.shortcut}`,
                refInFor: !0,
                attrs: { project: r, "marked-upload-area": "" },
                on: {
                  "files-added": function (i) {
                    return e.filesAdded(r.id);
                  },
                },
              });
            }),
            1
          ),
        ],
        1
      )
    );
  },
  Pt = [],
  It = n(kt, St, Pt, !1, null, null, null, null);
const Ut = It.exports,
  $t = o.extend({
    props: {
      backgroundColor: { type: String, default: "#b1eaef" },
      spinnerColor: { type: String, default: "#00b9ca" },
      progress: { type: Number, default: 0 },
      indeterminate: { type: Boolean, default: !1 },
      short: { type: Boolean, default: !1 },
      height: { type: String, default: "3px" },
    },
    data() {
      return { randomAnimationDelay: `${Math.random()}s` };
    },
    computed: {
      spinnerClasses() {
        return {
          indeterminate: this.indeterminate,
          "indeterminate--short": this.indeterminate && this.short,
          "progress-bar": !this.indeterminate,
        };
      },
      spinnerStyles() {
        const t = {};
        return (
          this.spinnerColor && (t.backgroundColor = this.spinnerColor),
          this.indeterminate
            ? (t.animationDelay = this.randomAnimationDelay)
            : (t.width = `${this.progress}%`),
          t
        );
      },
    },
  });
var Bt = function () {
    var e = this,
      s = e._self._c;
    return (
      e._self._setupProxy,
      s(
        "div",
        {
          staticClass: "ax-progress",
          style: { backgroundColor: e.backgroundColor, height: e.height },
        },
        [s("div", { class: e.spinnerClasses, style: e.spinnerStyles })]
      )
    );
  },
  Rt = [],
  Ot = n($t, Bt, Rt, !1, null, "c975704f", null, null);
const jt = Ot.exports,
  Dt = y({ required: !0 }),
  Nt = o.extend({
    components: { AxButton: w, AxIcon: f, AxProgressBar: jt },
    props: { item: Dt },
    data() {
      return { removed: !1 };
    },
    computed: {
      hidden() {
        return this.canceled || this.removed;
      },
      progressBarOptions() {
        const t = {
          height: "3px",
          indeterminate: this.indeterminate,
          progress: this.item.progress || 0,
        };
        return (
          this.item.status === h.Error &&
            ((t.spinnerColor = "#f90078"), (t.progress = 100)),
          t
        );
      },
      name() {
        return this.item.name;
      },
      exporting() {
        return this.item.status === h.Exporting;
      },
      inProgress() {
        const t = this.item.status;
        return t === h.Exporting || t === h.InProgress;
      },
      success() {
        return this.item.status === h.Success;
      },
      error() {
        return this.item.status === h.Error;
      },
      canceled() {
        return this.item.status === h.Canceled;
      },
      completed() {
        return this.success || this.error;
      },
      processing() {
        return this.inProgress && this.item.progress === 100;
      },
      indeterminate() {
        return (
          this.inProgress &&
          (this.item.progress === 0 || this.item.progress === 100)
        );
      },
      cancellable() {
        return (
          !this.canceled &&
          this.inProgress &&
          this.item.progress < 100 &&
          this.item.cancel !== void 0
        );
      },
      errorMessage() {
        return this.item.errorMessage;
      },
      linkToArtboardInspect() {
        if (this.item.serverArtboardId)
          return {
            name: u["expo.inspect"].name,
            params: {
              shortcut: this.item.shortcut,
              screen: this.item.serverArtboardId,
            },
          };
      },
      component() {
        return this.success && this.linkToArtboardInspect ? "AxButton" : "div";
      },
    },
    methods: {
      removeUpload() {
        this.removed = !0;
      },
      async cancelUpload() {
        this.item.cancel && (await this.item.cancel());
      },
    },
  });
var Et = function () {
    var e = this,
      s = e._self._c;
    return (
      e._self._setupProxy,
      s(
        "div",
        {
          directives: [
            {
              name: "show",
              rawName: "v-show",
              value: !e.hidden,
              expression: "!hidden",
            },
          ],
          staticClass: "row ax-artboards-upload-item",
        },
        [
          s(
            "div",
            { staticClass: "col" },
            [
              s(
                e.component,
                {
                  tag: "Component",
                  staticClass: "no-border w-100 ax-artboards-upload-item__link",
                  attrs: { to: e.linkToArtboardInspect, color: "link" },
                },
                [
                  s("div", { staticClass: "row g-0 align-items-center" }, [
                    s("div", { staticClass: "col truncate-ellipsis" }, [
                      e._v(" " + e._s(e.name) + " "),
                    ]),
                    s("div", { staticClass: "col-auto ms-3 text-end" }, [
                      e.exporting
                        ? s(
                            "div",
                            [
                              e._v(" Exporting "),
                              e.cancellable
                                ? s(
                                    "AxButton",
                                    {
                                      staticClass: "no-border",
                                      attrs: {
                                        color: "link",
                                        title: "Cancel",
                                        disable: e.canceled,
                                      },
                                      on: { click: e.cancelUpload },
                                    },
                                    [
                                      s("AxIcon", {
                                        staticClass: "ms-2",
                                        attrs: { name: "uploading-cancel" },
                                      }),
                                    ],
                                    1
                                  )
                                : e._e(),
                            ],
                            1
                          )
                        : e.cancellable
                        ? s(
                            "div",
                            [
                              s(
                                "AxButton",
                                {
                                  staticClass: "no-border",
                                  attrs: {
                                    color: "link",
                                    title: "Cancel",
                                    disable: e.canceled,
                                  },
                                  on: { click: e.cancelUpload },
                                },
                                [
                                  s("AxIcon", {
                                    staticClass: "ms-2",
                                    attrs: { name: "uploading-cancel" },
                                  }),
                                ],
                                1
                              ),
                            ],
                            1
                          )
                        : e.processing
                        ? s("div", [
                            s(
                              "span",
                              [
                                e._v(" Processing "),
                                s("AxIcon", {
                                  staticClass: "ms-2 text-body-secondary",
                                  attrs: { name: "uploading-cancel" },
                                }),
                              ],
                              1
                            ),
                          ])
                        : e.error
                        ? s(
                            "div",
                            [
                              s("span", { staticClass: "text-danger" }, [
                                e._v(" Failed "),
                              ]),
                              s(
                                "AxButton",
                                {
                                  staticClass: "text-danger no-border",
                                  attrs: { color: "link", title: "Remove" },
                                  on: { click: e.removeUpload },
                                },
                                [
                                  s("AxIcon", {
                                    staticClass: "ms-2",
                                    attrs: { name: "uploading-cancel" },
                                  }),
                                ],
                                1
                              ),
                            ],
                            1
                          )
                        : e.success
                        ? s("div", [
                            s(
                              "span",
                              [
                                e._v(" Complete "),
                                s("AxIcon", {
                                  staticClass: "ms-2",
                                  attrs: { name: "uploading-completed" },
                                }),
                              ],
                              1
                            ),
                          ])
                        : e._e(),
                    ]),
                  ]),
                  s(
                    "div",
                    { staticClass: "row g-0" },
                    [
                      s(
                        "AxProgressBar",
                        e._b(
                          { staticClass: "artboard-upload-progress-bar" },
                          "AxProgressBar",
                          e.progressBarOptions,
                          !1
                        )
                      ),
                    ],
                    1
                  ),
                ]
              ),
            ],
            1
          ),
        ]
      )
    );
  },
  Mt = [],
  Lt = n(Nt, Et, Mt, !1, null, "c3249889", null, null);
const Tt = Lt.exports,
  Wt = o.extend({ props: { value: { type: Boolean, default: !1 } } });
var Vt = function () {
    var e = this,
      s = e._self._c;
    return (
      e._self._setupProxy,
      e.value
        ? s(
            "div",
            { staticClass: "ax-page-notification" },
            [e._t("default")],
            2
          )
        : e._e()
    );
  },
  zt = [],
  qt = n(Wt, Vt, zt, !1, null, "fecd4a9d", null, null);
const Jt = qt.exports,
  Ht = o.extend({
    components: {
      AxArtboardUploadsItem: Tt,
      AxButton: w,
      AxIcon: f,
      AxPageNotification: Jt,
    },
    props: { batch: y({ required: !0 }) },
    data() {
      return { show: !0 };
    },
    computed: {
      projectName() {
        return this.batch && this.batch.projectName
          ? `to "${this.batch.projectName}"`
          : "";
      },
      uploadItems() {
        return this.batch ? this.batch.contents : {};
      },
      toProjectOverview() {
        if (this.batch)
          return {
            name: u["project.overview"].name,
            params: { shortcut: this.batch.shortcut },
          };
      },
      complete() {
        return this.batch
          ? this.$store.getters.batchIsCompleted(this.batch.id)
          : !1;
      },
    },
    methods: {
      close() {
        this.$emit("close");
      },
    },
  });
var Gt = function () {
    var e = this,
      s = e._self._c;
    return (
      e._self._setupProxy,
      s(
        "AxPageNotification",
        {
          model: {
            value: e.show,
            callback: function (r) {
              e.show = r;
            },
            expression: "show",
          },
        },
        [
          s(
            "div",
            {
              staticClass: "ax-artboard-uploads",
              attrs: { tabindex: "-1" },
              on: {
                keyup: function (r) {
                  return !r.type.indexOf("key") &&
                    e._k(r.keyCode, "esc", 27, r.key, ["Esc", "Escape"])
                    ? null
                    : e.close.apply(null, arguments);
                },
              },
            },
            [
              s("div", { staticClass: "ax-artboard-uploads-header" }, [
                s("div", { staticClass: "row" }, [
                  s("div", { staticClass: "col truncate-ellipsis" }, [
                    s(
                      "p",
                      { staticClass: "fw-semibold mb-4 truncate-ellipsis" },
                      [
                        s(
                          "Transition",
                          { attrs: { name: "fade-fast", mode: "out-in" } },
                          [
                            e.complete
                              ? s("span", { key: "complete" }, [
                                  e._v(
                                    " Upload " +
                                      e._s(e.projectName) +
                                      " Complete "
                                  ),
                                ])
                              : s("span", { key: "in-progress" }, [
                                  e._v(
                                    " Uploading Files " +
                                      e._s(e.projectName) +
                                      " "
                                  ),
                                ]),
                          ]
                        ),
                      ],
                      1
                    ),
                  ]),
                  s(
                    "div",
                    { staticClass: "col-auto" },
                    [
                      s(
                        "AxButton",
                        { attrs: { color: "link" }, on: { click: e.close } },
                        [
                          s("AxIcon", {
                            attrs: { name: "add", rotate: "45deg" },
                          }),
                        ],
                        1
                      ),
                    ],
                    1
                  ),
                ]),
              ]),
              s(
                "div",
                { staticClass: "ax-artboard-uploads-body mb-2" },
                e._l(e.uploadItems, function (r) {
                  return s("AxArtboardUploadsItem", {
                    key: r.id,
                    attrs: { item: r },
                  });
                }),
                1
              ),
              s(
                "div",
                { staticClass: "ax-artboard-uploads-footer" },
                [
                  s(
                    "AxButton",
                    {
                      attrs: {
                        to: e.toProjectOverview,
                        color: "primary",
                        block: "",
                        large: "",
                        "blur-on-click": "",
                      },
                    },
                    [e._v(" Go To Overview ")]
                  ),
                ],
                1
              ),
            ]
          ),
        ]
      )
    );
  },
  Qt = [],
  Kt = n(Ht, Gt, Qt, !1, null, "37c6ed49", null, null);
const Xt = Kt.exports,
  Yt = () =>
    _(
      () => import("./AxArtboardUploadsDesktopTracker-Dyru3eYS.js"),
      __vite__mapDeps([0, 1, 2, 3])
    ),
  Zt = o.extend({
    components: {
      AxArtboardUploadsDesktopTracker: Yt,
      AxArtboardUploadsPicker: Ut,
      AxArtboardUploadsProgress: Xt,
    },
    data() {
      return { isElectron: x };
    },
    computed: {
      batch() {
        const { uploads: t } = this.$store.state,
          e = Object.values(t.batches).filter((r) => r && !r.dismissed);
        return we(e, (r) => r.created)[0];
      },
      started() {
        if (this.batch) {
          const t = Object.values(this.batch.contents);
          for (const e of t) if (e.status !== h.NotStarted) return !0;
        }
        return !1;
      },
    },
    methods: {
      dismissBatch(t) {
        this.$store.commit(new T(t));
      },
    },
  });
var es = function () {
    var e = this,
      s = e._self._c;
    return (
      e._self._setupProxy,
      s(
        "div",
        [
          e.started && e.batch
            ? s("AxArtboardUploadsProgress", {
                key: e.batch.id,
                attrs: { batch: e.batch },
                on: {
                  close: function (r) {
                    return e.dismissBatch(e.batch.id);
                  },
                },
              })
            : e._e(),
          s("AxArtboardUploadsPicker"),
          e.isElectron ? s("AxArtboardUploadsDesktopTracker") : e._e(),
        ],
        1
      )
    );
  },
  ts = [],
  ss = n(Zt, es, ts, !1, null, null, null, null);
const rs = ss.exports,
  is =
    /^[v^~<>=]*?(\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+))?(?:-([\da-z\-]+(?:\.[\da-z\-]+)*))?(?:\+[\da-z\-]+(?:\.[\da-z\-]+)*)?)?)?$/i,
  j = (t) => {
    if (typeof t != "string")
      throw new TypeError("Invalid argument expected string");
    const e = t.match(is);
    if (!e)
      throw new Error(`Invalid argument not valid semver ('${t}' received)`);
    return e.shift(), e;
  },
  D = (t) => t === "*" || t === "x" || t === "X",
  N = (t) => {
    const e = parseInt(t, 10);
    return isNaN(e) ? t : e;
  },
  os = (t, e) => (typeof t != typeof e ? [String(t), String(e)] : [t, e]),
  ns = (t, e) => {
    if (D(t) || D(e)) return 0;
    const [s, r] = os(N(t), N(e));
    return s > r ? 1 : s < r ? -1 : 0;
  },
  E = (t, e) => {
    for (let s = 0; s < Math.max(t.length, e.length); s++) {
      const r = ns(t[s] || "0", e[s] || "0");
      if (r !== 0) return r;
    }
    return 0;
  },
  as = (t, e) => {
    const s = j(t),
      r = j(e),
      i = s.pop(),
      a = r.pop(),
      c = E(s, r);
    return c !== 0
      ? c
      : i && a
      ? E(i.split("."), a.split("."))
      : i || a
      ? i
        ? -1
        : 1
      : 0;
  },
  k = (t, e, s) => {
    ds(s);
    const r = as(t, e);
    return X[s].includes(r);
  },
  X = {
    ">": [1],
    ">=": [0, 1],
    "=": [0],
    "<=": [-1, 0],
    "<": [-1],
    "!=": [-1, 1],
  },
  M = Object.keys(X),
  ds = (t) => {
    if (typeof t != "string")
      throw new TypeError(
        `Invalid operator type, expected string but got ${typeof t}`
      );
    if (M.indexOf(t) === -1)
      throw new Error(`Invalid operator, expected one of ${M.join("|")}`);
  };
class us {
  constructor(e, s, r) {
    C(this, "clientVersion");
    C(this, "acknowledgedAt");
    (this.serverVersion = e),
      (this.serverReleaseDate = s),
      (this.outdatedAfter = r);
    let i = v.getLastVersion();
    i &&
      !i.version &&
      ((this.clientVersion = e), this.sync(), (i = v.getLastVersion())),
      i
        ? ((this.clientVersion = i.version),
          k(e, this.clientVersion, ">")
            ? ((this.acknowledgedAt = void 0), this.sync())
            : k(e, this.clientVersion, "<")
            ? ((this.acknowledgedAt = Date.now()), this.sync())
            : ((this.acknowledgedAt = i.acknowledgedAt),
              (this.serverReleaseDate = new Date(i.releaseDate))))
        : this.sync();
  }
  hasNewVersion() {
    return (
      !this.clientVersion || k(this.serverVersion, this.clientVersion, ">")
    );
  }
  sync() {
    v.setLastVersion({
      version: this.serverVersion,
      releaseDate: this.serverReleaseDate.getTime(),
      acknowledgedAt: this.acknowledgedAt,
    });
  }
  notifyAboutNewVersion(e) {
    if (!this.hasNewVersion() && this.acknowledgedAt) return !1;
    const s = new Date(this.serverReleaseDate);
    return nt(s, this.outdatedAfter) > new Date(e);
  }
  acknowledge() {
    (this.clientVersion = this.serverVersion),
      (this.acknowledgedAt = Date.now()),
      this.sync();
  }
}
const ls = o.extend({
  props: {
    dividerTop: { type: Boolean, default: !1 },
    dividerBottom: { type: Boolean, default: !1 },
  },
});
var cs = function () {
    var e = this,
      s = e._self._c;
    return (
      e._self._setupProxy,
      s(
        "li",
        {
          staticClass: "ax-list-item-static",
          class: {
            "ax-list-item--divider-top": e.dividerTop,
            "ax-list-item--divider-bottom": e.dividerBottom,
          },
        },
        [e._t("default")],
        2
      )
    );
  },
  ps = [],
  ms = n(ls, cs, ps, !1, null, "80d0ca32", null, null);
const hs = ms.exports,
  fs = [
    {
      title: "Axure Cloud for Business On Premises 2.0.0.441",
      date: "October 1, 2024",
    },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: [
        "Incorporates changes from September 24, 2024 update to Axure Cloud",
      ],
    },
    {
      title: "Bug Fixes & Performance Enhancements",
      isSubtitle: !0,
      points: ["Added support for generating RP11 prototypes"],
    },
    { title: "Axure Cloud Update", date: "September 24, 2024" },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: [
        "Sign in to Axure Cloud and Axure Portal with Google accounts",
        "Updated the design of the prototype player",
      ],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.440",
      date: "August 16, 2024",
    },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: [
        "Incorporates changes from August 13, 2024 update to Axure Cloud",
      ],
    },
    {
      title: "Bug Fixes & Performance Enhancements",
      isSubtitle: !0,
      points: ["Updated RP10 generator to 3922"],
    },
    { title: "Axure Cloud Update", date: "August 13, 2024" },
    {
      title: "Bug Fixes & Performance Enhancements",
      isSubtitle: !0,
      points: [
        "Upgraded to .NET8 for improved performance",
        "Minor notification email updates",
      ],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.439",
      date: "August 1, 2024",
    },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: ["Incorporates changes from July 23, 2024 update to Axure Cloud"],
    },
    {
      title: "Bug Fixes & Performance Enhancements",
      isSubtitle: !0,
      points: ["Updated RP10 generator to 3920"],
    },
    { title: "Axure Cloud Update", date: "July 23, 2024" },
    {
      title: "Bug Fixes & Performance Enhancements",
      isSubtitle: !0,
      points: [
        "Fixed issue where Axure Cloud links would not automatically unfurl to display a preview of the linked page when shared in messaging and collaboration applications",
        "Fixed intermittent connection errors when working in Axure Cloud",
      ],
    },
    {
      title: "Axure Cloud for Business",
      isSubtitle: !0,
      points: [
        "Fixed permission errors viewing a public link if workspace was set to Limit Access On",
      ],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.438",
      date: "July 11, 2024",
    },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: [
        "Incorporates changes from June 25, 2024 and July 9, 2024 updates to Axure Cloud",
      ],
    },
    {
      title: "Bug Fixes & Performance Enhancements",
      isSubtitle: !0,
      points: [
        "Fixed error creating database when using MySQL 8.4",
        "Fixed issue logging into OnPrem setups from the desktop cloud app",
      ],
    },
    { title: "Axure Cloud Update", date: "July 9, 2024" },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: [
        "Added option to share prototype links without an embedded access code",
        "Updated device sizes for Clickthrough projects",
        "Updated emails with 1-click unsubscribe option",
        "Updated design for notification emails",
      ],
    },
    {
      title: "Bug Fixes & Performance Enhancements",
      isSubtitle: !0,
      points: [
        "Fixed prototypes not loading with the Jira/Confluence plugin",
        "Updated member link behavior when link to current page is disabled",
        "Updated link in Share dialogs to allow for all configuration options when “Use current configuration” is enabled",
        "Checkbox selection is retained when closing and reopening Share dialogs",
        "Fixed issues around inviting user to a workspace through Request Access option",
        'Fixed Organization and First Workspace missing when creating account as Visitor or if account was originally created through <a href="www.portal.axure.com" target="_blank">www.portal.axure.com</a>',
      ],
    },
    { title: "Axure Cloud Update", date: "June 25, 2024" },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: [
        "Updated the sign in process to prepare for Google's third-party cookie restrictions",
      ],
    },
    {
      title: "Bug Fixes & Performance Enhancements",
      isSubtitle: !0,
      points: ["Fixed error publishing a file with same name from Axure RP"],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.437",
      date: "April 30, 2024",
    },
    {
      title: "Bug Fixes & Performance Enhancements",
      isSubtitle: !0,
      points: [
        "Fixed error upgrading the database when using MySQL version 5.7 and below",
      ],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.436",
      date: "April 19, 2024",
    },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: [
        "Incorporates changes from April 11, 2024 update to Axure Cloud",
      ],
    },
    { title: "Axure Cloud Update", date: "April 11, 2024" },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: ["Standardized naming convention of new and duplicated files"],
    },
    {
      title: "Bug Fixes & Performance Enhancements",
      isSubtitle: !0,
      points: [
        "Fixed issue where workspace would show comments as read when marking as unread",
        "Fixed issue where Members could remove Admins from workspaces",
        "Fixed view-only Guests/Members seeing incorrect UI",
        "Fixed error page on public link when project had no associated file",
        "Fixed Private Workspace missing from the desktop app",
        "Performance improvements",
      ],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.435",
      date: "March 26, 2024",
    },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: [
        "Incorporates changes from March 21, 2024 update to Axure Cloud",
      ],
    },
    { title: "Axure Cloud Update", date: "March 21, 2024" },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: [
        "Daily notification emails now include date of summary",
        "Added one-click unsubscribe for notification emails",
      ],
    },
    {
      title: "Bug Fixes & Performance Enhancements",
      isSubtitle: !0,
      points: ["Performance improvements"],
    },
    {
      title: "Axure Cloud for Business",
      isSubtitle: !0,
      points: ["Fixed Limit Access toggle working inconsistently"],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.434",
      date: "March 6, 2024",
    },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: [
        "Incorporates changes from February 27, 2024 update to Axure Cloud",
      ],
    },
    { title: "Axure Cloud Update", date: "February 27, 2024" },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: [
        "New create project workflow",
        "Changed behavior around auto-accepting workspace invitations for Organization changes",
      ],
    },
    {
      title: "Bug Fixes & Performance Enhancements",
      isSubtitle: !0,
      points: [
        'Fixed issue where team projects would fail to load if it contained a page named "Sitemap"',
        "Performance improvements",
      ],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.433",
      date: "February 9, 2024",
    },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: [
        "Incorporates changes from January 30, 2024 update to Axure Cloud",
      ],
    },
    {
      title: "Bug Fixes & Performance Enhancements",
      isSubtitle: !0,
      points: ["Updated RP10 generator to 3915"],
    },
    { title: "Axure Cloud Update", date: "January 30, 2024" },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: [
        "New download link for the Axure Cloud desktop app is now available in the Accounts menu dropdown",
        'Updated workflow for "Change Owner" and "Leave Workspace" actions to be more clear',
      ],
    },
    {
      title: "Bug Fixes & Performance Enhancements",
      isSubtitle: !0,
      points: [
        "Improved overall speed of loading workspaces",
        "Fixed workspace still loading in the sidebar when leaving the workspace",
      ],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.432",
      date: "January 23, 2024",
    },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: [
        "Incorporates changes from December 13, 2023 and January 16, 2024 updates to Axure Cloud",
      ],
    },
    {
      title: "Bug Fixes & Performance Enhancements",
      isSubtitle: !0,
      points: ["Updated RP10 generator to 3912"],
    },
    { title: "Axure Cloud Update", date: "January 16, 2024" },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: ["Organization name in breadcrumbs now link back to workspace"],
    },
    {
      title: "Bug Fixes & Performance Enhancements",
      isSubtitle: !0,
      points: [
        "Fixed archived workspaces appearing in Favorites",
        "Fixed workspace moving back to Favorites after leaving the workspace",
        "Fixed Favorited workspaces missing for selection when exporting from the desktop app or moving projects between workspaces",
        "Fixed incorrect workspace count in certain setups",
        "Fixed notification badge appearing for resolved comments",
        "Fixed missing 404 page",
        "Security improvements",
      ],
    },
    {
      title: "Axure Cloud for Business",
      isSubtitle: !0,
      points: [
        "Fixed an issue publishing to the Private Workspace on Axure Cloud for Business",
      ],
    },
    { title: "Axure Cloud Update", date: "December 13, 2023" },
    {
      title: "Feature Updates - Axure Cloud Organizations",
      isSubtitle: !0,
      points: [
        "Organizations add a centralized way to manage all your workspaces with your team",
        "Updated sidebar to reflect organization changes",
        "Manage Users: Designate permissions with roles (Super Admin, Admin, Member, and Guest)",
        "Join Workspaces: Users designated as Members can join workspaces without requiring an invitation",
        "View Workspace Membership: Admins can view workspaces users have access to",
      ],
    },
    {
      title: "Axure Cloud for Business",
      isSubtitle: !0,
      points: [
        'Invite-only workspaces: Workspaces can be "invite-only", requiring users to be invited before joining',
      ],
    },
    {
      title:
        'For more details on Organizations, please visit our blog: <a href="http://axure.com/blog/axure-cloud-organizations" target="_blank">http://axure.com/blog/axure-cloud-organizations</a>',
      isParapgraph: !0,
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.431",
      date: "October 25, 2023",
    },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: [
        "Incorporates changes from October 10, 2023 and October 19, 2023 updates to Axure Cloud",
      ],
    },
    {
      title: "Bug Fixes & Performance Enhancements",
      isSubtitle: !0,
      points: ["Updated RP10 generator to 3905"],
    },
    { title: "Axure Cloud Update", date: "October 19, 2023" },
    {
      title: "Bug Fixes & Performance Enhancements",
      isSubtitle: !0,
      points: ["Authentication updates"],
    },
    { title: "Axure Cloud Update", date: "October 10, 2023" },
    {
      title: "Bug Fixes & Performance Enhancements",
      isSubtitle: !0,
      points: [
        "Fixed error around the Last Modified column getting into a bad state",
        "Fixed comment pin not opening automatically when the comment was on a different page",
        "Fixed issue where switching from Default to Legacy in Project Viewing settings sometimes didn’t save (Project Viewing settings are being gradually rolled out and are currently only available to users in certain regions)",
      ],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.430",
      date: "September 4, 2023",
    },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: [
        "Incorporates changes from August 23, 2023 update to Axure Cloud",
      ],
    },
    {
      title: "Bug Fixes & Performance Enhancements",
      isSubtitle: !0,
      points: [
        "Fixed images not loading when using custom prototype domain setups",
      ],
    },
    { title: "Axure Cloud Update", date: "August 23, 2023" },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: [
        "Browser tab now shows user's location within Axure Cloud",
        "Changed default avatars to letters",
      ],
    },
    {
      title: "Bug Fixes & Performance Enhancements",
      isSubtitle: !0,
      points: [
        'Fixed browsing back to "Recents" page after closing browser tab',
        "Fixed team project showing loading spinner even after project was done generating",
        'Fixed "Share Link" option appearing under the Member Link tab when opening up the Share dialog from a member link project',
      ],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.429",
      date: "August 10, 2023",
    },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: [
        "Incorporates changes from August 8, 2023 update to Axure Cloud",
      ],
    },
    { title: "Axure Cloud Update", date: "August 8, 2023" },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: [
        "Updated the UI when generating RP projects and for generation failed projects",
        "Updated messaging for public links with no generated pages",
      ],
    },
    {
      title: "Bug Fixes & Performance Enhancements",
      isSubtitle: !0,
      points: ["Security improvements"],
    },
    {
      title: "Axure Cloud for Business",
      isSubtitle: !0,
      points: [
        "Removed First Workspace creation when signing into a new account",
      ],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.428",
      date: "July 25, 2023",
    },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: ["Incorporates changes from July 19, 2023 update to Axure Cloud"],
    },
    { title: "Axure Cloud Update", date: "July 19, 2023" },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: [
        "Modified column now lists the user who last modified the project",
      ],
    },
    {
      title: "Bug Fixes & Performance Enhancements",
      isSubtitle: !0,
      points: [
        "Fixed artboard projects showing incorrect links in Share dialog when logged out of Axure Cloud",
        "Fixed artboard projects with access codes not redirecting properly",
        "Fixed share link without prototype player directing to framed URL",
        "Fixed style effect properties not showing in Inspect when using a saved widget style",
        "Fixed wrong redirect resetting password when already signed into an account",
      ],
    },
    {
      title: "Axure Cloud for Business",
      isSubtitle: !0,
      points: [
        "Fixed error creating a team project with a Team license as a trial user",
      ],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.427",
      date: "July 12, 2023",
    },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: [
        "Incorporates changes from May 23, 2023, June 6, 2023, and June 29, 2023 updates to Axure Cloud",
      ],
    },
    {
      title: "Bug Fixes & Performance Enhancements",
      isSubtitle: !0,
      points: [
        "Fixed copying and pasting from Share dialog in-app not working on instances with HTTP setup",
        "Cleanup of temp generator folders",
        "Updated RP10 generator to 3899",
      ],
    },
    { title: "Axure Cloud Update", date: "June 29, 2023" },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: [
        "Change Dynamic Panel states through Inspect",
        "View style effect information through Inspect",
      ],
    },
    {
      title: "Bug Fixes & Performance Enhancements",
      isSubtitle: !0,
      points: [
        "Fixed notification badges not working in real time",
        "Security improvements",
      ],
    },
    {
      title: "Axure Cloud for Business",
      isSubtitle: !0,
      points: [
        "New Authentication and Settings tab for Admins",
        "Added setting to allow Admins to disable/enable creation of guest accounts from Guests or Members",
        "Users can now be added to the Axure Cloud for Business instance through workspace invitations",
      ],
    },
    { title: "Axure Cloud Update", date: "June 6, 2023" },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: [
        'Changed labeling for Workspace Roles from "Author" → "Can Edit" and "Viewer" → "View only"',
        "When choosing a role for users, text descriptions appear to give an explanation of permissions associated with the role",
        'Changed labeling for "Guest subscriptions" to "Visitor Subscriptions"',
      ],
    },
    {
      title: "Axure Cloud for Business",
      isSubtitle: !0,
      points: [
        'Divided Axure Cloud for Business "User Access Level" into "System Role" and "Axure RP Role" to offer more flexibility and control of user permissions',
        "Made it easier to assign seats from the Manage Accounts page",
        "Made it easier to see when someone is assigned a seat or validated as an RP Enterprise user",
      ],
    },
    {
      title: "Bug Fixes & Performance Enhancements",
      isSubtitle: !0,
      points: [
        "Fixed issue where Admins were unable to assign seat to themselves or other Admin",
      ],
    },
    { title: "Axure Cloud Update", date: "May 23, 2023" },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: [
        "Updated UI in project overview to easily find, change, and share access codes",
        "Prototype URLs now embed hashed access codes for protected projects generated from RP 10 builds 3898 and above",
        "Users now have the option to log in to their account when viewing a project with access code",
      ],
    },
    {
      title: "Bug Fixes & Performance Enhancements",
      isSubtitle: !0,
      points: [
        "Fixed issue with uploading a new profile photo in Manage Accounts",
        "Fixed enlarged category icons in emoji picker when using discussions",
        "Fixed page reloading when deleting a workspace",
        "Fixed copying and pasting @ mentions or emojis displaying incorrectly in comments",
      ],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.426",
      date: "April 5, 2023",
    },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: [
        "Incorporates changes from March 23, 2023 updates to Axure Cloud",
      ],
    },
    { title: "Axure Cloud Update", date: "March 23, 2023" },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: [
        "Workspace invitations will now automatically be accepted from users with matching company email domains",
        "The Workspace page will receive real-time updates whenever changes are made to project and workspace settings",
      ],
    },
    {
      title: "Bug Fixes & Performance Enhancements",
      isSubtitle: !0,
      points: [
        "Improved viewing private projects on mobile browsers",
        "Performance improvements",
        "Security improvements",
      ],
    },
    {
      title: "Axure Cloud for Business",
      isSubtitle: !0,
      points: [
        "Workspace invitations will now automatically be accepted from users within the same Axure Cloud for Business instance",
      ],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.425",
      date: "March 21, 2023",
    },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: [
        "Incorporates changes from February 15, 2023 and March 7, 2023 updates to Axure Cloud",
      ],
    },
    {
      title: "Bug Fixes & Performance Enhancements",
      isSubtitle: !0,
      points: ["Updated RP10 generator to 3896"],
    },
    { title: "Axure Cloud Update", date: "March 7, 2023" },
    {
      title: "Bug Fixes",
      isSubtitle: !0,
      points: [
        "Fixed copying content or CSS not working when inspecting page in-app",
      ],
    },
    {
      title: "Axure Cloud for Business",
      isSubtitle: !0,
      points: [
        "Adding new accounts on Axure Cloud for Business will add users in a publishing trial. During a publishing trial, users can publish projects without requiring an Axure RP Enterprise subscription or an Axure Cloud for Business seat",
        "Manage Accounts page has been updated to show users with a publishing trial and users who are limited from publishing",
        "Updated workflow for enabling Axure RP Enterprise. Seats will be assigned instead of enabling RP Enterprise",
        "Multiple accounts can now be assigned or unassigned seats",
      ],
    },
    { title: "Axure Cloud Update", date: "February 15, 2023" },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: [
        "Axure Cloud links that are shared in messaging and collaboration applications will now automatically unfurl to display a preview of the linked page",
        "The Project Overview page will receive real-time updates whenever changes are made to project and workspace settings",
        "The character limit for workspace invitation messages has been increased",
      ],
    },
    {
      title: "Bug Fixes & Performance Enhancements",
      isSubtitle: !0,
      points: [
        "Fixed members disappearing from workspaces when refreshing page inside workspace folder",
      ],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.424",
      date: "January 30, 2023",
    },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: [
        "Incorporates changes from January 19, 2023 update to Axure Cloud",
        "The Notifications page now informs users if email is not configured for the server",
      ],
    },
    {
      title: "Bug Fixes & Performance Enhancements",
      isSubtitle: !0,
      points: ["Updated RP10 generator to 3891"],
    },
    {
      title: "Note:",
      isSubtitle: !0,
      points: [
        "Upgrading the database might take longer than usual for this release, depending on the number of projects on the instance ",
      ],
    },
    { title: "Axure Cloud Update", date: "January 19, 2023" },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: [
        "While in a workspace, you can now mark comments on projects as read",
      ],
    },
    {
      title: "Bug Fixes & Performance Enhancements",
      isSubtitle: !0,
      points: ["Security improvements"],
    },
    {
      title: "Axure Cloud for Business",
      isSubtitle: !0,
      points: ["Fixed error when changing owner of a workspace"],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.423",
      date: "December 19, 2022",
    },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: [
        "Incorporates changes from December 14, 2022 update to Axure Cloud",
      ],
    },
    { title: "Axure Cloud Update", date: "December 14, 2022" },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: [
        "New status page in project overview when no pages were set to generate",
        "Improvements to searchable lists when moving prototypes or when adding/muting notifications",
      ],
    },
    {
      title: "Bug Fixes & Performance Enhancements",
      isSubtitle: !0,
      points: [
        "Fixed timezone appearing empty for some users",
        "Error generating project emails will now send to user who last published the project, rather than the workspace owner or the original generating user",
        "Fixed misalignment on project overview page when working with different display settings",
        "Fixed workspace buttons moving to the left when changing owner, deleting a workspace, or archiving a workspace",
        "Fixed error page when viewing publish details of deleted project from notification email",
        "Fixed error page when clicking on comment of deleted project from workspace feed",
      ],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.422",
      date: "December 1, 2022",
    },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: [
        "Incorporates changes from November 29, 2022 update to Axure Cloud",
      ],
    },
    { title: "Axure Cloud Update", date: "November 29, 2022" },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: [
        "Implemented searchable list in dialogs when moving prototypes or when adding/muting notifications",
      ],
    },
    {
      title: "Bug Fixes & Performance Enhancements",
      isSubtitle: !0,
      points: [
        "Fixed daily notification emails not sending with own publish/comment activity",
        "Fixed member prototype link opening without current configuration",
      ],
    },
    {
      title: "Axure Cloud for Business",
      isSubtitle: !0,
      points: [
        "Cleaned up emails when new instance/user is created and when migrating workspaces",
      ],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.421",
      date: "November 14, 2022",
    },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: [
        "Incorporates changes from November 9, 2022 update to Axure Cloud",
      ],
    },
    {
      title: "Bug Fixes & Performance Enhancements",
      isSubtitle: !0,
      points: [
        "Removed legacy notifications from On Premises setups",
        "Updated RP10 generator to 3887",
      ],
    },
    { title: "Axure Cloud Update", date: "November 9, 2022" },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: [
        "Updated Jira/Confluence integration to work with prototypes containing pretty URL settings",
        "Updated UX of Jira/Confluence integration",
      ],
    },
    {
      title: "Bug Fixes & Performance Enhancements",
      isSubtitle: !0,
      points: [
        "Fixed Microsoft Teams notifications not appearing if comments contained special characters",
        "Removed legacy notifications from Axure Cloud",
        "Further improvements for notification infrastructure",
      ],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.420",
      date: "October 31, 2022",
    },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: [
        "Incorporates changes from October 26, 2022 update to Axure Cloud",
      ],
    },
    {
      title: "Bug Fixes & Performance Enhancements",
      isSubtitle: !0,
      points: ["Updated RP10 generator to 3886"],
    },
    { title: "Axure Cloud Update", date: "October 26, 2022" },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: [
        "Refreshed UI",
        "Search bar now persists across all pages",
        "Axure logo now redirects to Recents",
      ],
    },
    {
      title: "Bug Fixes & Performance Enhancements",
      isSubtitle: !0,
      points: [
        "Improved notification timezone infrastructure",
        "Workspace members can now access member links in Axure Cloud via Jira/Confluence when an embedded prototype is made private",
      ],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.419",
      date: "October 21, 2022",
    },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: [
        "Incorporates changes from October 12, 2022 update to Axure Cloud",
      ],
    },
    { title: "Axure Cloud Update", date: "October 12, 2022" },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: ["Disabled project URLs now redirect to member links"],
    },
    {
      title: "Bug Fixes & Performance Enhancements",
      isSubtitle: !0,
      points: [
        "Enabling team project link from Axure RP will update share dialog upon opening",
        "Infrastructure improvements",
      ],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.418",
      date: "September 26, 2022",
    },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: [
        "Incorporates changes from September 22, 2022 update to Axure Cloud",
      ],
    },
    { title: "Axure Cloud Update", date: "September 22, 2022" },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: [
        "Comment filter popup will stay open after selecting filter options",
        "Updates to Create New Project screens",
      ],
    },
    {
      title: "Bug Fixes & Performance Enhancements",
      isSubtitle: !0,
      points: [
        "Fixed issue with clicking plugin button in the Chrome browser",
        "Fixed issue with Pretty URLs settings not working",
        "Security improvements",
      ],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.417",
      date: "September 9, 2022",
    },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: [
        "Incorporates changes from September 6, 2022 update to Axure Cloud",
      ],
    },
    { title: "Axure Cloud Update", date: "September 6, 2022" },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: [
        "The Project History page will show timestamps in full date and time format",
      ],
    },
    {
      title: "Bug Fixes & Performance Enhancements",
      isSubtitle: !0,
      points: [
        "Fixed comments being marked as unread after moving projects between workspaces",
        "Fixed issue with downloading assets from Inspect",
        "Increased font size in comments filter popup",
        "Removed the Post button while editing a comment",
        "Better handling of loading the Axure Handwriting Font when the page is set to Low Fidelity mode",
        "Improved performance when working with Axure Cloud",
      ],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.416",
      date: "August 25, 2022",
    },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: [
        "Incorporates changes from August 23, 2022 update to Axure Cloud",
      ],
    },
    { title: "Axure Cloud Update", date: "August 23, 2022" },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: [
        "Updated color scheme of Axure Cloud project icons to match Axure RP's file icons",
      ],
    },
    {
      title: "Bug Fixes & Performance Enhancements",
      isSubtitle: !0,
      points: ["Improved performance when working in Axure Cloud"],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.416",
      date: "August 25, 2022",
    },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: [
        "Incorporates changes from August 23, 2022 update to Axure Cloud",
      ],
    },
    { title: "Axure Cloud Update", date: "August 23, 2022" },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: [
        "Updated color scheme of Axure Cloud project icons to match Axure RP's file icons",
      ],
    },
    {
      title: "Bug Fixes & Performance Enhancements",
      isSubtitle: !0,
      points: ["Improved performance when working in Axure Cloud"],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.415",
      date: "August 16, 2022",
    },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: [
        "Incorporates changes from August 9, 2022 update to Axure Cloud",
      ],
    },
    {
      title: "Bug Fixes & Performance Enhancements",
      isSubtitle: !0,
      points: ["Updated RP10 generator to 3882"],
    },
    { title: "Axure Cloud Update", date: "August 9, 2022" },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: ["Renaming a project no longer changes its date modified"],
    },
    {
      title: "Bug Fixes & Performance Enhancements",
      isSubtitle: !0,
      points: [
        "Fixed issue where comment dialog wouldn’t appear when moving it to the edge of the screen",
        "Security improvements",
      ],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.414",
      date: "July 26, 2022",
    },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: ["Incorporates changes from July 19, 2022 update to Axure Cloud"],
    },
    {
      title: "Bug Fixes & Performance Enhancements",
      isSubtitle: !0,
      points: [
        "Fixed issue where generating a project with 0 pages selected would show an error in the public link",
        "Updated RP10 generator to 3879",
        "Updated RP9 generator to 3781",
      ],
    },
    { title: "Axure Cloud Update", date: "July 19, 2022" },
    {
      title: "Feature Updates",
      isSubtitle: !0,
      points: [
        "Projects now automatically refresh when generation is finished",
        "Updated project generation page with new UI",
        "Updated Access Code page with new UI",
      ],
    },
    {
      title: "Bug Fixes & Performance Enhancements",
      isSubtitle: !0,
      points: [
        "Fixed issue where phishing banner links were not clickable on iOS devices",
        "Fixed issue with comment dialog appearing behind the comment pane",
        "Fixed issue with comment placement after resizing browser window",
        "Fixed issue with artboards appearing too large when exported from Adobe XD or Sketch",
        "Fixed issue with Inspect reporting incorrect font weights when widgets had overwritten styles for fonts",
        "Project generation should no longer fail when an RP 10 team project only contains empty folders",
        "Improved Recents workspace to only show projects within 60 days",
        "Security Improvements",
      ],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.413",
      date: "June 23, 2022",
      points: [
        "Incorporates changes from June 21, 2022 update to Axure Cloud",
        "Updated RP9 generator to 3780",
        "Updated RP10 generator to 3876",
      ],
    },
    {
      title: "Axure Cloud Update: June 21, 2022",
      points: [
        "New ability to filter comments by unread, resolved, or comment color pin for RP 9 and RP 10 prototypes",
        "New ability to scroll while commenting on artboard projects",
        "Artboard projects now match the UI of the RP prototype player",
        "Fixed issue where scrolling within the comment would scroll the entire prototype",
        "Fixed issue where shadow properties were not appearing in Inspect for dynamic panels",
        'Fixed issue where clicking the "@" icon or emoji icon in the comment reply dialog would focus back on the text area',
        "Fixed bug with taking snapshots in comments",
        "Optimization improvements",
      ],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.412",
      date: "May 31, 2022",
      points: [
        "Incorporates changes from May 25, 2022 update to Axure Cloud",
        "Fixed issue with generating projects containing a snapshot widget referencing a page with an SVG",
        "Updated RP10 generator to 3873",
      ],
    },
    {
      title: "Axure Cloud Update: May 25, 2022",
      points: [
        "New commenting improvements for RP projects",
        "Updated text on project overview page to reflect the number of widgets in widget libraries",
        "Fixed issue with loading notification badges on public Cloud links",
        "Fixed issue with loading Cloud accounts containing a [space] at the end of the email",
        "Security improvements",
      ],
    },
    {
      title: "Axure Cloud for Business",
      isSubtitle: !0,
      points: [
        "Added endpoint for improved verification of Enterprise licenses",
      ],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.411",
      date: "April 27, 2022",
      points: [
        "Incorporates changes from April 20, 2022 update to Axure Cloud",
        "Updated RP10 generator to 3870",
      ],
    },
    {
      title: "Axure Cloud Update: April 20, 2022",
      points: [
        "Updated and refreshed UI style applied to the prototype player matching the latest RP 10 build",
        'New "Share" functionality in the prototype player allowing you to easily share prototypes links with others while still viewing the prototype',
        "You can now mark comments as unread, making it easier to manage your comment workflows",
        "Added ability to copy links to individual comments, great for directing team members to a specific location on the prototype",
        "Publish dialogs now contain more concise Cloud URLs",
        "New hotkey - pressing [Esc] while adding a comment will allow you to quickly exit comment mode",
        "Added ability to downgrade RP 10 team projects back to RP 8 team projects in support of some new RP workflows",
        "Improved workflow when requesting to join a workspace",
        "Fixed issue with loading artboards in new browser tab/window",
        "Fixed issue with loading History tab for heavy projects",
        'Fixed issue where the "Invite" button in project overview was visible for reviewers in workspaces',
        "Fixed issue with reopening pages panel for RP 8 projects",
      ],
    },
    {
      title: "Axure Cloud for Business",
      isSubtitle: !0,
      points: [
        'Fixed issue where "Technical Admins" could downgrade "Super Admins" to a lower access level',
      ],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.409",
      date: "March 8, 2022",
      points: [
        "Incorporates changes from March 3, 2022 update to Axure Cloud",
        "Updated RP10 generator to 3860",
      ],
    },
    {
      title: "Axure Cloud Update: March 3, 2022",
      points: [
        "Implemented additional caching to improve prototype performance",
        "Fixed issue with general lag around deleting plugins, guest subscriptions, and workspaces",
        "Fixed comment counts not appearing correctly on workspaces with folders containing projects with 0 comments",
        "Fixed issue with alignment when deleting access codes on RP8- projects",
        "Security improvements",
      ],
    },
    {
      title: "Axure Cloud for Business",
      isSubtitle: !0,
      points: [
        "Fixed issue where instance can get into a state without a Super Admin",
        "Fixed issue with alignment on saving SAML settings",
      ],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.408",
      date: "February 7, 2022",
      points: [
        "Incorporates changes from sunsetting legacy Axure Share on November 30, 2021",
        "Incorporates changes from January 11, 2022 updates to Axure Cloud",
        "Fixed issue with widget notes in dynamic panels appearing out of alignment",
        "Updated RP9 generator to 3757 and RP10 generator to 3857",
      ],
    },
    {
      title: "Axure Cloud Update: January 11, 2022",
      points: [
        "Improved upon the prototype sharing experience for public and member links. These improvements make it easier to customize the initial viewing experience for your stakeholders when clicking on the share link",
        "Fixed issue with pretty URLs redirecting to the default page when an Access Code is applied",
      ],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.407",
      date: "November 17, 2021",
      points: [
        "Incorporates changes from November 10, 2021 update to Axure Cloud",
        "Updated RP10 generator to 3851",
      ],
    },
    {
      title: "Axure Cloud Update: November 10, 2021",
      points: [
        "Email notifications will now reflect your current time zone; this has been implemented for both regular as well as guest accounts",
        "You can now manually adjust your Cloud account's time zone via the Notification Center page",
        "Prototype share link URLs can now be copied directly from the project overview page",
        "Updates to the device list for artboard projects",
        "Fixed an issue with blank pages for locally downloaded projects in the mobile app",
        "Fixed an issue downloading projects locally on the mobile app when only some pages were set to generate",
        "Fixed an issue with Cloudfront URLs replacing image extensions in certain file setups",
        "Fixed Polish characters rending incorrectly when using Open Sans font",
        "Fixed font styles rending incorrectly between different adaptive views",
        "Fixed generation error when no pages were set to generate",
      ],
    },
    {
      title: "Axure Cloud for Business",
      isSubtitle: !0,
      points: ['Added "Limit Access" option when creating a new workspace'],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.406",
      date: "September 29, 2021",
      points: [
        "Incorporates changes from September 23, 2021 update to Axure Cloud",
        "Fixed issue with Chinese characters rendering incorrectly on publish",
        "Fixed issue with workspace not loading due to high comment count",
        "Updated RP10 generator to 3844",
      ],
    },
    {
      title: "Axure Cloud Update: September 23, 2021",
      points: [
        'Pretty URLs and Redirect functionality is now supported for RP projects in Axure Cloud under the "Advanced" tab',
        "Added ability to view prototype Access Codes",
        "Inspect now surfaces padding properties and image file types",
        "Fixed issue with maintaining image file types from projects created in Axure RP",
        "Fixed issue with border properties in Inspect",
        "Fixed issue with component changes missing in Team Project history for RP 10 projects",
        "Fixed issue with border highlight when renaming a workspace in Firefox and Safari ",
      ],
    },
    {
      title: "Axure Cloud for Business",
      isSubtitle: !0,
      points: [
        'Prototype Passwords are now referred to as "Access Codes"',
        "Added ability to easily change the Super Admin of your instance",
      ],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.405",
      date: "August 24, 2021",
      points: [
        "Incorporated changes from August 18, 2021 update to Axure Cloud",
        "Updated RP10 generator to 3838",
      ],
    },
    {
      title: "Axure Cloud Update: August 18, 2021",
      points: [
        "You can now download multiples images at once while inspecting",
        "Fixed pinning comments for large prototypes",
        "Fixed pinning comments when zooming in/out with custom device settings",
        "Fixed invitation icon placement in workspace list",
        "Fixed plugin placement with multiple pages or long page names",
      ],
    },
    {
      title: "Axure Cloud for Business",
      isSubtitle: !0,
      points: [
        "Improved Cloud license setup and management",
        "Fixed total comment count to include unread @mentions",
        "Enhanced Axure Cloud security",
      ],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.404",
      date: "July 14, 2021",
      points: [
        "Incorporated changes from July 12, 2021 update to Axure Cloud",
        "Removed customsettings.readme file for manual installs of OnPrem",
        "Updated RP10 Generator to 3830",
      ],
    },
    {
      title: "Axure Cloud Update: July 12, 2021",
      points: [
        "Improved formatting and organization of Team Project commit notes",
        "Updated @mention styling",
        "Improved organization and readability of comment metadata within the comment panel",
        "New crisp RP projects icons",
        "Improved product security",
        "Fixed issue opening comments on pages with a horizontal scroll",
        "Fixed issue scrolling a prototype while using Inspect with the Confluence Cloud integration",
        "Fixed issue triggering interactions in masters for artboard projects",
        "Fixed icons not appearing on Private/Recents workspaces",
        'Fixed "Copy Code" button not appearing in Firefox',
      ],
    },
    {
      title: "Axure Cloud for Business",
      isSubtitle: !0,
      points: [
        "Increased grace period length to 14 days for an expired Cloud license",
        "Expiration emails are now sent to all admins 30 days prior to an annual Cloud license expiring",
        "Fixed issue with lines disappearing on hover for project/user lists",
      ],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.403",
      date: "June 01, 2021",
      points: [
        "Incorporates changes from May 24, 2021 update to Axure Cloud",
        "Updated RP10 Generator to 3828",
      ],
    },
    {
      title: "Axure Cloud Update: May 24, 2021",
      points: [
        "UI refresh!",
        "Backend framework update",
        "Fixed Artboard projects not zooming correctly on Firefox",
        "Fixed background image availability in Inspect",
        "Fixed trimmed leading quotes for fonts in Inspect",
        "Updated user prototype limit text",
        "Fixed intermittent errors with dormant tabs",
        "Fixed menu appearing in What's New dialog",
      ],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.402",
      date: "April 29, 2021",
      points: [
        "Incorporates changes from April 22, 2021 update to Axure Cloud",
        "Added support for RP10",
        "Fixed issue verifying Enterprise users",
        "Updated RP10 Generator to 3824",
        "Updated RP9 Generator to 3727",
      ],
    },
    {
      title: "Axure Cloud Update: April 22, 2021",
      points: [
        "Inspect now available in public link (RP10 and Artboard projects)",
        "Pan & Zoom added to prototypes (RP10)",
        "Synching of prototype scroll and zoom settings for Preview/Inspect transitions (RP10)",
        "Updated zoom options for Artboard projects",
        "Updated RP10 icons",
        "Fixed comment bubble locations when not in scroll frame",
        "Fixed preview page sticking after new project generation",
      ],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.331",
      date: "April 12, 2021",
      points: [
        "Added support for SMTP anonymous authentication",
        "Fixed upgrade to secure SMTP connection",
      ],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.330",
      date: "April 5, 2021",
      points: ["Incorporates changes from April 2, 2021 update to Axure Cloud"],
    },
    {
      title: "Axure Cloud Update: April 2, 2021",
      points: ["General updates for Axure RP10 support"],
    },
    {
      title: "Axure Cloud for Business",
      isSubtitle: !0,
      points: ["Fixed some Reviewer level users having Team Projects access"],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.328",
      date: "March 2, 2021",
      points: [
        "Incorporates changes from February 25th, 2021 update to Axure Cloud",
        "Updated RP9 Generator to 3723",
      ],
    },
    {
      title: "Axure Cloud Update: February 25, 2021",
      points: [
        "Revamp to prototype discussions infrastructure and UI",
        "Discussion threads are now marked as read/unread individually",
        "Fixed comment post button obscuring below client’s visible window",
        "Fixed resizing of client window exiting comment pin mode",
        "Fixed inability to resolve user comments for RP8 projects",
        "Fixed problems logging in to mobile app when duplicate accounts exist",
        "Fixed Axure Cloud logo missing from notification emails",
      ],
    },
    {
      title: "Axure Cloud for Business",
      isSubtitle: !0,
      points: [
        "Fixed signing out via discussions for SSO users",
        "Fixed Technical Admins inability to sign in using standard authentication",
        "Admin Settings panel is set to Technical Admins’ default state",
        "Fixed Technical Admins inability to manage Super Admin and Admin accounts",
      ],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.327",
      date: "February 1, 2021",
      points: [
        "Incorporates changes from January 28th, 2021 update to Axure Cloud",
        "Fixed issue with resetting password through command prompt",
        "Fixed freeze on creating a workspace when email server has wrong port",
        "Fixed SSL/non-SSL settings for email servers",
        "Fixed issue with loading pages in IE",
      ],
    },
    {
      title: "Axure Cloud Update: January 28, 2021",
      points: [
        "Added Workspace access requests for protected prototypes",
        "New Welcome to Axure Cloud email",
        "Added iPhone 12 models to artboard project size settings",
        "Allow muting notifications for Workspaces",
        "Added Workspace name change event to feed",
        "Fixed long Workspace names breaking Slack/MS Teams notifications",
        "Fixed encoding issues for user nick names",
        "Additional security enhancements",
      ],
    },
    {
      title: "Axure Cloud for Business",
      isSubtitle: !0,
      points: [
        "Addition of Technical Admin user type",
        "Non-Workspace members @mentioned in Publish notes are now given guest subscription",
      ],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.326",
      date: "December 21, 2020",
      points: [
        "Addressed password validation issue for Active Directory using LDAP authentication",
      ],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.325",
      date: "December 15, 2020",
      points: [
        "Incorporates changes from December 15, 2020 update to Axure Cloud",
        "Added increased flexibility for custom proxy settings",
        "Replaced &ldquo;HostHttpOnly&rdquo; setting with &ldquo;MatchProtocolMode&rdquo; setting",
      ],
    },
    {
      title: "Axure Cloud Update: December 15, 2020",
      points: [
        "Added Workspace access requests for protected prototypes",
        "Added ability to post comments as a guest user",
        "Added ability to @mention guest commenters",
        "Removed the ability to leave anonymous comments",
        "Added ability to mark a comment resolved with a reply",
        "UI improvements to commenting flow",
        "Improvements to Workspace invitation emails",
        "Changes to how default avatars are assigned",
        "No longer exposing full email addresses in prototype comment pane",
        "Added 50 user limit for Workspace invitations",
        "Fixed inability to re-send Workspace invitations",
        "Fixed including existing Workspace members from blocking valid invitations",
        "Fixed loading Feedback comments when nickname contains special characters",
        "Fixed sending deleted comment notification when replies are deleted",
        "Fixed scroll line obscuring error message when Workspace invitation fails",
        "Additional security enhancements and bug fixes",
      ],
    },
    {
      title: "Axure Cloud for Business",
      isSubtitle: !0,
      points: ["Clearer messaging when deactivated users attempt to sign in"],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.324",
      date: "November 13, 2020",
      points: ["Fixed unresponsiveness during large Team Project operations"],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.323",
      date: "October 22, 2020",
      points: [
        "Incorporates changes from October 21, 2020 update to Axure Cloud",
        "RP9 generator updated to 3717",
      ],
    },
    {
      title: "Axure Cloud Update: October 21, 2020",
      points: [
        "Added Guest Subscriptions",
        "Added ability to @mention Guests",
        "Feedback thread participants now receive reply notifications",
        "Enhanced Notification Center UI",
        "Removed Daily Summary Notification checkbox",
        "Added unsubscribe links to email notifications",
        "Added default user avatar images",
        "Allowing Feedback pin numbers to exceed 99",
        "Fixed deleted projects breaking Workspace feed after 30 days",
        "Fixed linking to Feedback comment from email",
        "Fixed page refresh when showing/hiding Feedback pins",
        "Fixed page refresh when canceling Feedback comment delete",
        "Fixed Delete Comment notification referring to New Comment",
        "Fixed Marked Resolved notification referring to New Comment",
        "Fixed Workspace Feed hyperlink click behavior and hover style",
        "Fixed responsiveness of emails viewed on desktop devices",
        "Fixed issues including qq email addresses in Workspace invites",
        "Fixed receiving emails for project updates with “Some” notification setting",
        "Fixed performance/crashing issues for projects with many resolved comments",
        "Security enhancements",
      ],
    },
    {
      title: "Axure Cloud for Business",
      isSubtitle: !0,
      points: ["Fixed SSO Logout URL verification issues"],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.322",
      date: "September 24, 2020",
      points: [
        "Incorporates changes from September 22, 2020 update to Axure Cloud",
        "Test email now uses full email pipeline",
        "Enhancements to Active Directory configuration screen",
      ],
    },
    {
      title: "Axure Cloud Update: September 22, 2020",
      points: [
        "Allow links in Feedback comments",
        "Enhanced detection of Cloud version updates",
        "Fixed showing active tabs when visiting Cloud from Axure RP",
        "Fixed http redirect after entering prototype password for public urls",
        "Fixed redirect to prototype password page when opening http RP8 projects from Cloud UI",
        "Removed default Publish Note message",
        "Improved error handling for websockets",
        "Security enhancements",
      ],
    },
    {
      title: "Axure Cloud for Business",
      isSubtitle: !0,
      points: [
        "Allow setting SSO authentication for multiple users",
        "Allow SSO log in to create new Reviewer accounts",
        "Automatically selecting SSO authentication for new users when SSO configured",
        "Improved add user account flow",
        "Increased password scrutiny for System Admins on Axure Cloud for Business creation",
        "Fixed error signing in to Axure Cloud for Business using multiple accounts",
      ],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.321",
      date: "September 11, 2020",
      points: [
        "Incorporates changes from September 8, 2020 update to Axure Cloud",
        "Fixed resetting admin password via command prompt ",
        "RP9 generator updated to 3715",
        "RP8 generator updated to 3392",
      ],
    },
    {
      title: "Axure Cloud Update: September 8, 2020",
      points: ["Added Workspace Activity Feed", "Bug fixes"],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.320",
      date: "August 28, 2020",
      points: [
        "Fixed accessing password protected prototypes for HTTP instances",
      ],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.319",
      date: "August 3, 2020",
      points: ["Improvements to email notifications", "Security enhancements"],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.318",
      date: "July 24, 2020",
      points: [
        "Incorporates changes from July 22, 2020 update to Axure Cloud",
        "Exposing OnPrem version to all users",
        "Added support for @mentioning and inviting “Administrator”",
      ],
    },
    {
      title: "Axure Cloud Update: July 22, 2020",
      points: [
        "Email notifications revamp",
        "Added “What’s New” section to the menu",
        "Allow for adding comment text to clipboard",
        "Added support for shadows in Inspect",
        "Feedback pin number now tracked across entire project",
        "Other general Feedback enhancements",
        "Using desktop notifications to alert user of Workspace invitations",
        "Added modified date to folders",
        "Improved messaging for when @mentions isn’t available",
        "Updated device list for Artboard projects",
        "Fixed error renaming Masters in Artboard projects",
        "Allow for folders to have the same name as projects",
        "Preventing anonymous Feedback users from marking comments as resolved",
        "Workspace invites come from inviter not from Workspace owner",
        "Improvements to Slack/MS Teams notifications",
      ],
    },
    {
      title: "Axure Cloud for Business",
      isSubtitle: !0,
      points: [
        "Added support for batch inviting users to Workspaces",
        "Including invite message when inviting to Workspace via @mention",
        "Fixed issues with First Workspace after downgrading authors to reviewers",
      ],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.317",
      date: "July 7, 2020",
      points: [
        "Incorporates changes from July 1, 2020 update to Axure Cloud (except for workspace migration)",
        "Better logging for generation errors",
        "RP9 generator updated to 3704",
      ],
    },
    {
      title: "Axure Cloud Update: July 1, 2020",
      points: [
        "Added support for migrating Workspaces from Axure Cloud for Business",
        "Added last modified date column to folders",
        "Enabled download for Feedback screenshot tool for Edge browser in prototype player",
        "Default Cloud avatar changes with nickname",
        "Better detection when Workspace invitations accepted in other tabs",
        "Fixed desktop notifications not showing custom profile avatars",
        "Fixed comment replies updating user nicknames",
        "Fixed scrolling beyond bottom of artboard after flip animations",
        "Enabled multiple authentication methods for hubs",
        "Patched CSRF vulnerabilities",
        "Better enforcement of filetype restrictions for artboard uploads",
        "Better obscuring of user information in password reset tokens",
        "Added HttpOnly flag for cookies",
        "Various bug fixes and security enhancements",
      ],
    },
    {
      title: "Axure Cloud for Business",
      isSubtitle: !0,
      points: [
        "Added support for migrating Workspaces from Axure Cloud",
        "Surfacing total license and used license count on Admin Page",
        "Added support for activating/disabling multiple accounts at once",
        "Enhancements to user management on Admin Page",
        "Restricted @mention options available to Reviewers",
        "Various bug fixes and security enhancements",
      ],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.316",
      date: "May 13, 2020",
      points: [
        "Incorporates changes from May 11, 2020 update to Axure Cloud",
        "Enhanced logging for project generation timeouts",
      ],
    },
    {
      title: "Axure Cloud Update: May 11, 2020",
      points: [
        "Added support for emojis in discussion comments and publish notes",
        "Added desktop notifications for @mentions",
        "Added support for @mentioning in publish notes",
        "Added Help and Feedback menu options",
        "Added Figma elements to cloud UI",
        'Enabled "Show Hotspots" for artboard projects in mobile player',
        "Exposed full discussion comments in mobile player",
        "Added fixes and enhancements to Leave Workspace flow",
        "Other bug fixes and enhancements",
      ],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.315",
      date: "April 14, 2020",
      points: [
        "Incorporates changes from April 9, 2020 update to Axure Cloud",
        "Fixed generator to handle gzip errors gracefully",
        "Added support for multiple Active Directories across different domains",
        "Added SkipAxShareHostCheck flag to support certain proxy configurations",
      ],
    },
    {
      title: "Axure Cloud Update: April 9, 2020",
      points: [
        "Added publish notes for non-team-projects and artboard projects",
        "Updated project History page",
        "Updated prototype password UI for new Advanced projects",
        "Added project Overview refresh when stale data detected",
        "Fixed deleting multiple screens from Build page",
        "Fixed bugs moving projects out of folders",
        "Fixed bugs with long breadcrumb chains",
        "Fixed bugs with @mentions/badging feature",
      ],
    },
    {
      title: "Axure Cloud for Business",
      isSubtitle: !0,
      points: [
        "Prevented sending emails to deactivated users",
        "Fixed bugs with @mentions/badging feature",
      ],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.314",
      date: "March 27, 2020",
      points: [
        "Incorporates changes from March 25, 2020 update to Axure Cloud",
        "Custom ports now allowed for MySql database installation",
        'Fixed issues with "=" character in database passwords',
        "Fixed Axure Handwriting font not appearing correctly",
        "Database connection strings now hidden in logs",
      ],
    },
    {
      title: "Axure Cloud Update: March 25, 2020",
      points: [
        "Added @Mentioning feature for Discussions",
        "Added Workspace member sharing links",
        "Added Auto (Web) platform option for Basic Projects",
        "Clearer active state for current Workspace",
        "Discussion comment counts surfaced on folders",
        "New responsive prototype password page",
        "Fixed Opacity CSS setting for Inspect of Basic Projects",
      ],
    },
    {
      title: "Axure Cloud for Business",
      isSubtitle: !0,
      points: ["Fixed deactivated users still appearing as Workspace members"],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.313",
      date: "February 28, 2020",
      points: [
        "Incorporates changes from February 26, 2020 update to Axure Cloud",
        "Improved formatting for OnPrem logs",
        "Fixed freezing issue with improperly entered email server credentials",
      ],
    },
    {
      title: "Axure Cloud Update: February 26, 2020",
      points: [
        "Added ability to favorite Workspaces",
        "Added ability to archive Workspaces",
        "Added reCAPTCHA for inviting users to Workspaces with optional message",
        "Added email chipping to new Workspace creation flow",
        "Order of artboards is maintained better when uploading to Cloud",
        "Better differentiation between pending and accepted Workspace members",
        "Better differentiation between shared and unshared Workspaces",
        "Fixed screenshot plugin installation dialog opening behind other elements",
      ],
    },
    {
      title: "Axure Cloud for Business",
      isSubtitle: !0,
      points: [
        "Added email chipping to account creation for Sys-Admins/Admins",
        "Sys-Admins/Admins can toggle off non-member workspaces when moving, adding notifications, and exporting artboards",
      ],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.312",
      date: "February 7, 2020",
      points: [
        "Incorporates changes from February 5, 2020 update to Axure Cloud",
        "Added ability to disable Google fonts requests",
        "Fixed logging in to feedback with Active Directory/LDAP",
      ],
    },
    {
      title: "Axure Cloud Update: February 5, 2020",
      points: [
        'Renamed "My Projects" to "Private Workspace"',
        "Consolidated workspace overflow menu",
        "Standard workspace created for new users",
        "Workspace invitation emails link directly to pending workspaces",
        "Renaming workspaces will rename for all members",
        "Revamped workspace management workflow",
        "Further improvements to artboard upload status dialog",
        "Fixed bugs resulting in unnecessary comment badging",
        "Fixed issues logging in to Axure Cloud for long existing accounts",
      ],
    },
    {
      title: "Axure Cloud for Business",
      isSubtitle: !0,
      points: [
        "Workspace invitations can now be accepted or declined",
        "Users can now leave workspaces from the workspace settings menu",
        "Admins and System Admins can see workspace owners by hovering over workspace names in the left sidebar",
        "Admins and System Admins can now join workspaces directly from the workspace settings menu",
        "Fixed sending notifications to Admins and System Admins for workspaces they haven't joined",
      ],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.310",
      date: "January 21, 2020",
      points: [
        "Incorporates changes from January 15, 2020 update to Axure Cloud",
        "Added support for LDAPS authentication",
        "Fixed authentication with Active Directory/LDAP via feedback",
        "Fixed domain field for Active Directory setup not working",
        "Fixed requiring password changes on login for Active Directory and LDAP environments",
        "Changes to SameSite Cookie settings to prepare for increased browser security updates",
      ],
    },
    {
      title: "Axure Cloud Update: January 15, 2020",
      points: [
        "Added badge notifications for discussion comments",
        "Improved artboard upload status dialog",
        "Added ability to modify screen order from project Overview page",
        "Fixed browser freezing when inspecting artboards with large assets",
        "Added banner for Internet Explorer users suggesting use of other browsers",
      ],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.309",
      date: "December 20, 2019",
      points: [
        "Incorporates changes from December 11, 2019 update to Axure Cloud",
        "Fixed errors preventing service start up after updates",
        "Fixed redirecting to localhost when visiting Axure Cloud for Business externally when there are database issue",
        "Fixed issues deleting artboard projects",
      ],
    },
    {
      title: "Axure Cloud Update: December 11, 2019",
      points: [
        "Enhancements to Discussions",
        "Enhancements to Cloud Project management menu",
        "Enhancements to Read Only mode behavior",
        "Fixed bug sending daily digest emails to former workspace members",
        "Fixed errors using Internet Explorer",
      ],
    },
    {
      title: "Axure Cloud for Business",
      isSubtitle: !0,
      points: ["Fixed crowding and bugs in Workspace invite dialog"],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.307",
      date: "November 6, 2019",
      points: [
        "Incorporates changes from October 29, 2019 update to Axure Cloud",
        "Enforcing strict passwords for system administrators",
        "Enhancements to manual install options",
        "Support for host header verification",
      ],
    },
    {
      title: "Axure Cloud Update: October 29, 2019",
      points: [
        "Enhancements to artboard project previewing",
        "Fixed generation failures for RP projects with common special characters in name",
        "Optimizations to artboard project asset download from Inspect",
        "Fixed connection errors editing MS Teams notifications",
        "Enhanced security against script injection vulnerabilities",
        "Updates to workspace invitation emails",
        "Further bug fixes",
      ],
    },
    {
      title: "Axure Cloud for Business",
      isSubtitle: !0,
      points: [
        "Fixed missing SSO error pages",
        "Implemented remembering visible workspace setting between sessions",
        "Fixed redirect with alternate SSO login path",
        "Fix for unnecessary re-auths to SSO enabled instances",
        "Further bug fixes",
      ],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.306",
      date: "October 10, 2019",
      points: ["Fixed bug with differential generation for team projects"],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.305",
      date: "September 24, 2019",
      points: [
        "Incorporates changes from September 18, 2019 update to Axure Cloud",
        "Better error messaging for database connection issues",
        "Added ability to block setup routes when ACB update requires database schema change",
        "Fixed bugs using Internet Explorer during ACB configuration",
      ],
    },
    {
      title: "Axure Cloud Update: September 18, 2019",
      points: [
        "New configuration options for email notifications",
        "Fixed needing prototype password when clicking from Axure Cloud UI",
        "Fixed closing dialogs accidentally when selecting text",
        "Fixed loading team libraries as viewer only",
        "Bug fixes and security enhancements",
      ],
    },
    {
      title: "Axure Cloud for Business",
      isSubtitle: !0,
      points: [
        "Fixed redirect with SSO login",
        "Increased password requirements:",
        "Must be at least 8 characters long",
        "Must contain at least 1 number",
        "Must contain both upper and lowercase letters",
        "Must not contain 3 or more sequential or repeating characters (<code>123</code>, <code>AAA</code>)",
      ],
    },
    {
      title: "Axure Cloud for Business On Premises 2.0.0.304",
      date: "August 16, 2019",
      points: [
        "Incorporates changes from August 15, 2019 update to Axure Cloud",
        `For servers that were upgraded from Axure Share Enterprise (Version 8), the following settings have been moved
    from the database into customsettings.json:`,
        "Web app domain name/URL",
        "SSL",
        "Max file size for uploads",
      ],
    },
    {
      title: "Axure Cloud Update: August 15, 2019",
      points: [
        "Artboard project screens can now be deleted from the project's Overview page.",
        "Performance enhancements and bug fixes.",
      ],
    },
    {
      title: "Axure Cloud for Business",
      isSubtitle: !0,
      points: [
        `Axure Cloud For Business now supports
    <a href="https://docs.axure.com/axure-cloud/basics/notifications/#slack">Slack Notifications</a>.`,
        "Author accounts can now create workspaces and invite other users to them.",
        `Administrator accounts are no longer automatically added to every workspace. Instead, they can view every
     workspace and self-invite as needed.`,
      ],
    },
    {
      title: "Axure Cloud for Business On-Premises 2.0.0.302",
      date: "July 15, 2019",
      points: [
        `Incorporates changes from public Axure Cloud and adds support for Axure RP 9 files.<br>
    Contact your Axure account representative or
    <a href="https://www.axure.cloud/onprem-contact/">complete this form to request more information</a>.`,
      ],
    },
    {
      title: "The New Axure Cloud is now available!",
      date: "April 25, 2019",
      points: [
        "Find out <a href='https://www.axure.com/blog/welcome-to-the-new-axure#axure-cloud'>what's new in Axure Cloud</a>",
      ],
    },
    { title: "Axure Share Enterprise (On-Premises 8)", isSupertitle: !0 },
    {
      title: "Version 1.0.0.214",
      date: "January 24, 2020",
      points: [
        "Changes to SameSite Cookie settings to prepare for increased browser security updates",
      ],
    },
    {
      title: "Version 1.0.0.207",
      points: ["Fixes to support MySQL 8.0", "TLS 1.2 Fixes"],
    },
    {
      title: "Version 1.0.0.206",
      points: [
        "Fixes for FIPS Compliance",
        "Support for LDAP",
        "Improvements to simplify configuration",
      ],
    },
    {
      title: "Version 1.0.0.195",
      points: [
        "SAML Improvements",
        "Fixes for generation issues on low-memory machines",
      ],
    },
    {
      title: "Version 1.0.0.191",
      points: [
        "Incorporates AxShare redesign",
        "8.1 features",
        "Windows Server 2016 fixes",
        "non-ssl SMTP emailer",
      ],
    },
    {
      title: "Version 1.0.0.186",
      points: [
        "Update to support Axure RP 8.1 Team Project features",
        "Bug fixes",
      ],
    },
    {
      title: "Version 1.0.0.176",
      points: [
        "added support for AxShareApp",
        "Merge latest AxShare Cloud changes",
        "allowed changing max file size or generation timeout",
        "Generator 3321",
      ],
    },
    {
      title: "Version 1.0.0.171",
      points: [
        "Added ability to see the previous version of the prototype while the new team project commit is generating",
        "Merge AxShare Cloud codebase",
      ],
    },
    {
      title: "Version 1.0.0.168",
      points: ["Reset account lockout when Administrator sets a user password"],
    },
    {
      title: "Version 1.0.0.167",
      points: [
        "Added Notifications for:",
        "Versions (New, Edit)",
        "Projects (New, Edit)",
        "Fixed issue with subscribing to notifications from Admin accounts (Super Admins worked correctly)",
        "Changed the cleanup algorithm to recover space from deleted prototypes much more aggressively",
        "Fixed issues setting values with an @ symbol (particularly notification sender email address) on MySQL databases",
        "Added a custom error page to alert users when the application cannot connect to the database",
        "Fixed issue installing on machines with cultures where the Local Service account was localized",
        "Various UI enhancements in the Axure Share Manager",
        "Various usability fixes for Axure Share",
      ],
    },
    {
      title: "Version 1.0.0.159",
      points: [
        "Fixed errors when uploading larger files in memory constrained environments",
      ],
    },
    {
      title: "Version 1.0.0.153",
      points: [
        "Fix for issues with Windows 2012 R2 not correctly installing IIS",
      ],
    },
    { title: "Version 1.0.0.151", points: ["Initial RTM Release"] },
  ],
  gs = o.extend({
    data() {
      return { releases: fs };
    },
  });
var xs = function () {
    var e = this;
    return e._self._c, e._self._setupProxy, e._m(0);
  },
  ws = [
    function () {
      var t = this,
        e = t._self._c;
      return (
        t._self._setupProxy,
        e(
          "div",
          { staticClass: "release-history" },
          t._l(t.releases, function (s, r) {
            return e("div", { key: r }, [
              s.isParapgraph
                ? e("p", { domProps: { innerHTML: t._s(s.title) } })
                : s.isSupertitle
                ? e("h2", { domProps: { innerHTML: t._s(s.title) } })
                : s.isSubtitle
                ? e("h4", { domProps: { innerHTML: t._s(s.title) } })
                : e("h3", { domProps: { innerHTML: t._s(s.title) } }),
              s.date
                ? e("p", { staticClass: "release-history-date" }, [
                    e("em", [t._v(" " + t._s(s.date))]),
                  ])
                : t._e(),
              s.points && s.points.length
                ? e(
                    "ul",
                    t._l(s.points, function (i) {
                      return e("li", {
                        key: i,
                        domProps: { innerHTML: t._s(i) },
                      });
                    }),
                    0
                  )
                : t._e(),
            ]);
          }),
          0
        )
      );
    },
  ],
  bs = n(gs, xs, ws, !1, null, "0af6d598", null, null);
const vs = bs.exports,
  As = o.extend({
    components: { AxDialog: be, AxReleaseHistory: vs },
    data() {
      return { dialog: !0 };
    },
    computed: {
      isOnPrem() {
        const { axShareConfig: t } = this.$store.state;
        return t !== null && t.AxShareOnPrem;
      },
    },
    methods: {
      cancel() {
        (this.dialog = !1), this.$emit("cancel");
      },
    },
  });
var ys = function () {
    var e = this,
      s = e._self._c;
    return (
      e._self._setupProxy,
      s(
        "AxDialog",
        {
          attrs: { "content-class": "ax-whats-new-dialog__content" },
          on: { toggle: e.cancel },
          model: {
            value: e.dialog,
            callback: function (r) {
              e.dialog = r;
            },
            expression: "dialog",
          },
        },
        [
          s("div", { staticClass: "form-title" }, [
            e._v(" What's new in Axure Cloud "),
          ]),
          e.isOnPrem
            ? s("AxReleaseHistory")
            : s("iframe", {
                attrs: {
                  src: "https://www.axure.com/release-history/axure-cloud?embedto=app",
                  width: "100%",
                  height: "600px",
                  frameborder: "0",
                },
              }),
        ],
        1
      )
    );
  },
  _s = [],
  Fs = n(As, ys, _s, !1, null, null, null, null);
const Cs = Fs.exports,
  ks = o.extend({
    components: {
      AxButton: w,
      AxDropdownButton: ve,
      AxIcon: f,
      AxList: Ae,
      AxListItem: ye,
      AxListItemStatic: hs,
      AxUser: _e,
      AxWhatsNewDialog: Cs,
    },
    props: { linkClasses: { type: String, default: "" } },
    data() {
      const t = Ue,
        e = $e,
        s = v.getLastVersion();
      return {
        useTimer: void 0,
        now: new Date(),
        outdatedAfter: { days: 4 },
        lastVersion: s,
        feedbackUrl: t,
        productHelpUrl: e,
        AnalyticsClickEvents: W,
        whatsNewDialog: !1,
        notificationsRoute: u.notification,
        manageAccountRoute: u["manage.account"],
        versionCheck: void 0,
        adminSettingsRoute: {
          name: $.routes.admin.name,
          path: $.routes.admin.path,
        },
        desktopUrl: Fe,
      };
    },
    computed: {
      axShareConfig() {
        const { axShareConfig: t } = this.$store.state;
        return t || void 0;
      },
      isSubInstanceAdmin() {
        return this.$store.getters.isSubInstanceAdmin;
      },
      loaded() {
        return !!this.userInfo && !!this.userProfile;
      },
      userInfo() {
        const { user: t } = this.$store.state;
        return t.userInfo;
      },
      userProfile() {
        const { user: t } = this.$store.state;
        return t.profile;
      },
      userName() {
        var t, e;
        return (
          ((t = this.userInfo) == null ? void 0 : t.nickname) ||
          ((e = this.userInfo) == null ? void 0 : e.userEmail) ||
          ""
        );
      },
      isOnPrem() {
        return !!this.axShareConfig && this.axShareConfig.AxShareOnPrem;
      },
      showVersion() {
        return (
          !!this.axShareConfig &&
          this.axShareConfig.AxShareOnPrem &&
          !!this.axShareConfig.Version
        );
      },
      version() {
        return !this.axShareConfig || !this.axShareConfig.Version
          ? ""
          : this.axShareConfig.Version;
      },
      serverVersion() {
        return this.isOnPrem
          ? this.version
          : !this.axShareConfig || !this.axShareConfig.ReleaseDate
          ? ""
          : this.releaseDate.getTime().toString();
      },
      releaseDate() {
        if (this.isOnPrem) return new Date();
        if (!this.axShareConfig || !this.axShareConfig.ReleaseDate)
          return new Date();
        try {
          return at(this.axShareConfig.ReleaseDate);
        } catch {
          return new Date();
        }
      },
      notifyAboutNewVersion() {
        return this.versionCheck
          ? this.versionCheck.notifyAboutNewVersion(this.now)
          : !1;
      },
      isElectron() {
        return x;
      },
    },
    async created() {
      this.useTimer = setInterval(() => {
        this.now = new Date();
      }, 36e5);
      const { user: e } = this.$store.state;
      e.userInfo || this.$store.dispatch(new Ce()),
        e.profile || this.$store.dispatch(new ke()),
        (this.versionCheck = new us(
          this.serverVersion,
          this.releaseDate,
          this.outdatedAfter
        )),
        x && window.AxureCloudNative.ipc.on(Se.Logout, this.logout);
    },
    beforeDestroy() {
      this.useTimer && clearInterval(this.useTimer);
    },
    methods: {
      moveNotificationRoute() {
        return { name: u.notification.name };
      },
      manageAccount(t) {},
      openWhatsNewDialog() {
        this.versionCheck &&
          (this.versionCheck.acknowledge(), (this.now = new Date())),
          (this.whatsNewDialog = !0);
      },
      closeWhatsNewDialog() {
        this.whatsNewDialog = !1;
      },
      async logout() {
        const t = () =>
            new Promise((s, r) => {
              const i = Be({ name: u.login.name });
              i ? this.$router.push(i, () => s(), r) : s();
            }),
          e = () =>
            new Promise((s, r) => {
              const { accountService: i, axShareConfig: a } = this.$store.state;
              if (i) {
                const c = i().getLogoutUrl(a);
                window.location.href = c;
              }
              s();
            });
        x && window.AxureCloudNative.ipc.send(Pe.LogoutPerformed),
          await this.$store.dispatch(new Ie(t, e));
      },
    },
  });
var Ss = function () {
    var e = this,
      s = e._self._c;
    return (
      e._self._setupProxy,
      e.loaded
        ? s(
            "div",
            [
              s(
                "AxDropdownButton",
                {
                  staticClass: "account-menu-list desktop-app-no-drag",
                  attrs: {
                    arrow: "",
                    color: "link",
                    "content-class": "account-menu-list-content",
                    "drop-max-height": !0,
                    distance: 10,
                  },
                  scopedSlots: e._u(
                    [
                      {
                        key: "button",
                        fn: function () {
                          return [
                            s(
                              "div",
                              {
                                class:
                                  e.AnalyticsClickEvents.UserProfile.eventClass,
                              },
                              [
                                s("AxUser", {
                                  attrs: {
                                    "username-classes": e.linkClasses,
                                    user: e.userInfo,
                                    profile: e.userProfile,
                                    "show-notification-badge":
                                      e.notifyAboutNewVersion,
                                    "show-username": !1,
                                  },
                                  scopedSlots: e._u(
                                    [
                                      {
                                        key: "append",
                                        fn: function () {
                                          return [
                                            s("AxIcon", {
                                              staticClass: "icon-caret",
                                              attrs: { name: "caret" },
                                            }),
                                          ];
                                        },
                                        proxy: !0,
                                      },
                                    ],
                                    null,
                                    !1,
                                    2301379065
                                  ),
                                }),
                              ],
                              1
                            ),
                          ];
                        },
                        proxy: !0,
                      },
                    ],
                    null,
                    !1,
                    752963218
                  ),
                },
                [
                  s(
                    "AxList",
                    { staticClass: "desktop-app-no-drag" },
                    [
                      s(
                        "AxListItemStatic",
                        {
                          staticClass: "ax-account-menu__username",
                          attrs: { "divider-bottom": "" },
                        },
                        [e._v(" " + e._s(e.userName) + " ")]
                      ),
                      e.isSubInstanceAdmin
                        ? s(
                            "AxListItem",
                            [
                              s(
                                "AxButton",
                                {
                                  attrs: {
                                    medium: "",
                                    color: "link",
                                    to: e.adminSettingsRoute,
                                  },
                                },
                                [e._v(" 管理账户 ")]
                              ),
                            ],
                            1
                          )
                        : e._e(),
                      s(
                        "AxListItem",
                        [
                          s(
                            "AxButton",
                            {
                              attrs: {
                                medium: "",
                                color: "link",
                                to: e.notificationsRoute,
                              },
                            },
                            [e._v(" 通知 ")]
                          ),
                        ],
                        1
                      ),
                      s(
                        "AxListItem",
                        [
                          s(
                            "AxButton",
                            {
                              attrs: {
                                medium: "",
                                color: "link",
                                to: e.manageAccountRoute,
                              },
                            },
                            [e._v(" 账户中心 ")]
                          ),
                        ],
                        1
                      ),
                      s(
                        "AxListItem",
                        {
                          staticClass: "item-with-notification",
                          attrs: { "divider-top": "" },
                        },
                        [
                          s(
                            "AxButton",
                            {
                              attrs: { medium: "", color: "link" },
                              on: { click: e.openWhatsNewDialog },
                            },
                            [e._v("有什么新内容 ")]
                          ),
                          e.notifyAboutNewVersion
                            ? s("AxIcon", {
                                staticClass: "notification-badge",
                                attrs: { name: "dot" },
                              })
                            : e._e(),
                        ],
                        1
                      ),
                      e.productHelpUrl
                        ? s(
                            "AxListItem",
                            [
                              s(
                                "AxButton",
                                {
                                  attrs: {
                                    medium: "",
                                    color: "link",
                                    target: "_blank",
                                    rel: "noopener",
                                    href: e.productHelpUrl,
                                  },
                                },
                                [e._v(" 帮助 ")]
                              ),
                            ],
                            1
                          )
                        : e._e(),
                      e.feedbackUrl
                        ? s(
                            "AxListItem",
                            [
                              s(
                                "AxButton",
                                {
                                  attrs: {
                                    medium: "",
                                    color: "link",
                                    target: "_blank",
                                    rel: "noopener",
                                    href: e.feedbackUrl,
                                  },
                                },
                                [e._v(" 提供反馈 ")]
                              ),
                            ],
                            1
                          )
                        : e._e(),
                      e.isElectron
                        ? e._e()
                        : s(
                            "AxListItem",
                            {
                              attrs: {
                                "divider-top": "",
                                "divider-bottom": "",
                              },
                            },
                            [
                              s(
                                "AxButton",
                                {
                                  attrs: {
                                    medium: "",
                                    color: "link",
                                    target: "_blank",
                                    rel: "noopener",
                                    href: e.desktopUrl,
                                  },
                                },
                                [e._v(" 获取桌面应用程序 ")]
                              ),
                            ],
                            1
                          ),
                      s(
                        "AxListItem",
                        [
                          s(
                            "AxButton",
                            {
                              attrs: { medium: "", color: "link" },
                              on: { click: e.logout },
                            },
                            [e._v(" 退出登录 ")]
                          ),
                        ],
                        1
                      ),
                      e.showVersion
                        ? s("AxListItemStatic", [
                            s("div", { staticClass: "ax-version-info" }, [
                              e._v(" Version (" + e._s(e.version) + ") "),
                            ]),
                          ])
                        : e._e(),
                    ],
                    1
                  ),
                ],
                1
              ),
              e.whatsNewDialog
                ? s("AxWhatsNewDialog", {
                    on: { cancel: e.closeWhatsNewDialog },
                  })
                : e._e(),
            ],
            1
          )
        : e._e()
    );
  },
  Ps = [],
  Is = n(ks, Ss, Ps, !1, null, "a3259900", null, null);
const Us = Is.exports,
  $s = o.extend({
    components: { AxAxureLogo: Re, AxIcon: f },
    computed: {
      isRecentActive() {
        return this.$route.name === u["fs.recents"].name;
      },
      recentsRoute() {
        return {
          name: u["fs.recents"].name,
          query: { refresh: this.isRecentActive ? "true" : "" },
        };
      },
    },
  });
var Bs = function () {
    var e = this,
      s = e._self._c;
    return (
      e._self._setupProxy,
      s(
        "RouterLink",
        { staticClass: "ax-home-logo-link", attrs: { to: e.recentsRoute } },
        [s("AxIcon", [s("AxAxureLogo")], 1)],
        1
      )
    );
  },
  Rs = [],
  Os = n($s, Bs, Rs, !1, null, "0961b216", null, null);
const js = Os.exports,
  Ds = o.extend({
    components: { AxIcon: f, AxProjectThumbnail: Oe, AxFolder: je },
    props: {
      result: y({ required: !0, default: null }),
      query: { type: String, default: "" },
    },
    computed: {
      chunks() {
        return this.result.getStringChunks("name") || [];
      },
      isProject() {
        return this.result.item.type === d.Shortcut;
      },
      projectType() {
        return this.result.item.subtype !== void 0
          ? this.result.item.subtype
          : NaN;
      },
      shortcutState() {
        return this.result.item.shortcutState;
      },
      projectResourceDirVersion() {
        return this.result.item.resourceDirVersion !== void 0
          ? this.result.item.resourceDirVersion
          : NaN;
      },
      isFolder() {
        return this.result.item.type === d.Folder;
      },
      icon() {
        switch (this.result.item.type) {
          case d.Workspace:
            return "workspace";
          case d.Folder:
            return "folder";
          default:
            return "axure_page";
        }
      },
    },
  });
var Ns = function () {
    var e = this,
      s = e._self._c;
    return (
      e._self._setupProxy,
      s("span", { staticClass: "ax-search-result" }, [
        s(
          "span",
          { staticClass: "ax-search-thumbnail" },
          [
            e.isProject
              ? s("AxProjectThumbnail", {
                  attrs: {
                    state: e.shortcutState,
                    type: e.projectType,
                    version: e.projectResourceDirVersion,
                    small: "",
                  },
                })
              : e.isFolder
              ? e.isFolder
                ? s("AxIcon", [s("AxFolder")], 1)
                : e._e()
              : s("AxIcon", {
                  staticClass: "ax-search-thumbnail__icon",
                  attrs: { name: e.icon },
                }),
          ],
          1
        ),
        s(
          "span",
          { staticClass: "ax-search-text" },
          e._l(e.chunks, function (r, i) {
            return s("span", { key: i, class: { "fw-semibold": r.isBold } }, [
              e._v(e._s(r.text)),
            ]);
          }),
          0
        ),
      ])
    );
  },
  Es = [],
  Ms = n(Ds, Ns, Es, !1, null, "55a234f9", null, null);
const Ls = Ms.exports,
  Ts = o.extend({
    components: { AxHeaderSearchResult: Ls },
    props: {
      result: { type: Object, default: null },
      query: { type: String, default: "" },
      disabled: { type: Boolean, default: !1 },
    },
    computed: {
      isViewOnly() {
        return this.isProject ? !!this.result.item.viewOnly : !1;
      },
      isProject() {
        return this.result.item.type === d.Shortcut;
      },
      route() {
        const { result: t } = this;
        switch (t.item.type) {
          case d.Shortcut:
            return this.routeOverview;
          case d.Workspace:
          case d.Folder:
            return this.fsLocation;
          default:
            return this.fsLocation;
        }
      },
      routeOverview() {
        const { result: t } = this;
        return {
          name: u["project.overview"].name,
          params: { shortcut: t.item.id },
        };
      },
      fsLocation() {
        const { result: t } = this;
        return t.item.type === d.Folder && t.item.workspaceId
          ? B(t.item, { workspaceId: t.item.workspaceId })
          : B(t.item);
      },
    },
  });
var Ws = function () {
    var e = this,
      s = e._self._c;
    return (
      e._self._setupProxy,
      s(
        "div",
        { staticClass: "ax-header-search-result-link" },
        [
          e.disabled
            ? s(
                "div",
                [
                  s("AxHeaderSearchResult", {
                    attrs: { result: e.result, query: e.query },
                  }),
                ],
                1
              )
            : s(
                "RouterLink",
                { staticClass: "search-result-link", attrs: { to: e.route } },
                [
                  s("AxHeaderSearchResult", {
                    attrs: { result: e.result, query: e.query },
                  }),
                ],
                1
              ),
        ],
        1
      )
    );
  },
  Vs = [],
  zs = n(Ts, Ws, Vs, !1, null, "94340750", null, null);
const qs = zs.exports,
  Js = o.extend({
    components: { AxShortcutModified: De },
    props: { item: { type: Object, default: null } },
    computed: {
      canShowModifiedDate() {
        return this.item.type === d.Shortcut || this.item.type === d.Folder;
      },
      project() {
        return this.$store.getters.getFsNode(this.item.id);
      },
    },
  });
var Hs = function () {
    var e = this,
      s = e._self._c;
    return (
      e._self._setupProxy,
      e.canShowModifiedDate
        ? s("AxShortcutModified", {
            attrs: {
              "project-id": e.item.lastUpdatedShortcut,
              "project-modified": e.item.updated,
              "project-modified-by": e.item.lastUpdatedBy,
              "project-state": e.item.shortcutState,
            },
          })
        : e._e()
    );
  },
  Gs = [],
  Qs = n(Js, Hs, Gs, !1, null, null, null, null);
const Ks = Qs.exports,
  Xs = o.extend({
    components: {
      AxDataTableNoData: Ne,
      AxFilesystemTable: Ee,
      AxHeaderSearchResultLink: qs,
      AxShortcutDropdownButton: Me,
      AxSearchResultModified: Ks,
      AxShortcutPublicLink: Le,
      AxSpinnerImage: Te,
    },
    props: {
      loading: { type: Boolean, default: !1 },
      results: V({ required: !1, default: () => [] }),
      query: { type: String, default: "" },
      headerOffsetTop: { type: Number, default: 0 },
    },
    data() {
      return {
        deletedItems: {},
        clonedItems: {},
        movedItems: {},
        renamedItems: {},
      };
    },
    computed: {
      items() {
        return this.results.map((t) => ({
          ...t.item,
          shortcutType: t.item.subtype,
        }));
      },
      searchResults() {
        return We(this.results, (t) => t.item.id);
      },
      headers() {
        return [
          {
            text: `${this.results.length.toString()} 文本的结果 "${
              this.query
            }"`,
            value: "name",
          },
          { text: "ID", value: "id", sortable: !1 },
          { text: "修改人", value: "updated", width: "15%" },
          { text: "", sortable: !1, width: "10%" },
        ];
      },
    },
    methods: {
      isProject(t) {
        return t.type === d.Shortcut;
      },
      showShortcutDropdown(t) {
        return t.type === d.Shortcut && t.viewOnly === !1;
      },
      prototypeUrls(t) {
        const { axShareConfig: e } = this.$store.state;
        return z(e, t.prototypeUrl || "", t.id);
      },
      searchResult(t) {
        return this.searchResults[t.id];
      },
      idChunks(t) {
        const e = this.searchResult(t);
        return e ? e.getStringChunks("id") || [] : [];
      },
      itemDeleted(t) {
        this.$set(this.deletedItems, t.id, !0);
      },
      isItemDeleted(t) {
        return !!this.deletedItems[t.id];
      },
      itemCloned(t) {
        this.$set(this.clonedItems, t.id, !0);
      },
      itemMoved(t) {
        this.$set(this.movedItems, t.id, !0);
      },
      itemRenamed(t) {
        this.$set(this.renamedItems, t.id, !0);
      },
      itemModified() {
        this.$emit("modified");
      },
    },
  });
var Ys = function () {
    var e = this,
      s = e._self._c;
    return (
      e._self._setupProxy,
      s(
        "div",
        { staticClass: "ax-filesystem-search-table" },
        [
          e.loading
            ? s(
                "div",
                { staticClass: "d-flex justify-content-center pt-3" },
                [s("AxSpinnerImage")],
                1
              )
            : s("AxFilesystemTable", {
                attrs: {
                  items: e.items,
                  headers: e.headers,
                  loading: e.loading,
                  "header-offset-top": e.headerOffsetTop,
                  "item-navigation-disabled": e.isItemDeleted,
                  "select-disabled": "",
                  "pagination-disabled": "",
                  "actions-header-disabled": "",
                },
                scopedSlots: e._u([
                  {
                    key: "content",
                    fn: function ({ item: r }) {
                      return [
                        s(
                          "td",
                          { staticClass: "ax-filesystem-node-link" },
                          [
                            s("AxHeaderSearchResultLink", {
                              attrs: {
                                result: e.searchResult(r),
                                query: e.query,
                                disabled: e.isItemDeleted(r),
                              },
                            }),
                          ],
                          1
                        ),
                        s("td", [
                          e.isProject(r)
                            ? s(
                                "div",
                                [
                                  s(
                                    "AxShortcutPublicLink",
                                    {
                                      attrs: {
                                        project: r,
                                        "prototype-urls": e.prototypeUrls(r),
                                        disabled: e.isItemDeleted(r),
                                      },
                                    },
                                    e._l(e.idChunks(r), function (i, a) {
                                      return s(
                                        "span",
                                        {
                                          key: a,
                                          class: { "fw-semibold": i.isBold },
                                        },
                                        [s("span", [e._v(e._s(i.text))])]
                                      );
                                    }),
                                    0
                                  ),
                                ],
                                1
                              )
                            : e._e(),
                        ]),
                        s(
                          "td",
                          [s("AxSearchResultModified", { attrs: { item: r } })],
                          1
                        ),
                        s(
                          "td",
                          [
                            e.showShortcutDropdown(r)
                              ? s("AxShortcutDropdownButton", {
                                  attrs: { "refresh-disabled": "", project: r },
                                  on: {
                                    deleted: e.itemDeleted,
                                    cloned: e.itemCloned,
                                    moved: e.itemMoved,
                                    renamed: e.itemRenamed,
                                    modified: e.itemModified,
                                  },
                                })
                              : e._e(),
                          ],
                          1
                        ),
                      ];
                    },
                  },
                  {
                    key: "noData",
                    fn: function () {
                      return [
                        s("AxDataTableNoData", {
                          attrs: {
                            title: "未找到结果",
                            "sub-title": "请尝试不同的关键词",
                          },
                        }),
                      ];
                    },
                    proxy: !0,
                  },
                ]),
              }),
        ],
        1
      )
    );
  },
  Zs = [],
  er = n(Xs, Ys, Zs, !1, null, "ddce4f2a", null, null);
const tr = er.exports,
  sr = o.extend({
    components: {
      FilesystemViewer: Ve,
      AxFilesystemSearchTable: tr,
      AxFilesystemViewerHeader: ze,
      AxFilesystemViewerActionsBase: qe,
      AxIcon: f,
    },
    props: {
      loading: { type: Boolean, default: !1 },
      query: { type: String, default: "" },
      results: V({ default: () => [] }),
    },
    data() {
      return {
        searchNode: {
          id: "search",
          name: "搜索结果",
          type: d.Search,
          listingNode: void 0,
          parent: void 0,
          totalItems: 0,
          created: new Date(),
        },
        modified: !1,
        node: void 0,
      };
    },
    computed: {
      navigating() {
        return this.$store.getters.navigating;
      },
    },
    activated() {
      this.reInitData();
    },
    created() {
      this.reInitData();
    },
    async deactivated() {
      await this.refreshNavigate();
    },
    async beforeDestroy() {
      await this.refreshNavigate();
    },
    methods: {
      onModified() {
        this.modified = !0;
      },
      async refreshNavigate() {
        this.modified &&
          this.node &&
          (await this.$store.dispatch(new m(this.node)));
      },
      reInitData() {
        (this.modified = !1), (this.node = this.$store.getters.current.node);
      },
    },
  });
var rr = function () {
    var e = this,
      s = e._self._c;
    return (
      e._self._setupProxy,
      s(
        "div",
        { staticClass: "ax-filesystem-search" },
        [
          e.navigating
            ? e._e()
            : s("FilesystemViewer", {
                attrs: { "content-divider": "" },
                scopedSlots: e._u(
                  [
                    {
                      key: "header-content",
                      fn: function () {
                        return [
                          s("AxFilesystemViewerActionsBase", {
                            scopedSlots: e._u(
                              [
                                {
                                  key: "node-icon",
                                  fn: function () {
                                    return [
                                      s("AxIcon", {
                                        attrs: { name: "search" },
                                      }),
                                    ];
                                  },
                                  proxy: !0,
                                },
                                {
                                  key: "node-name",
                                  fn: function () {
                                    return [
                                      s("AxFilesystemViewerHeader", {
                                        attrs: { node: e.searchNode },
                                      }),
                                    ];
                                  },
                                  proxy: !0,
                                },
                              ],
                              null,
                              !1,
                              3875194863
                            ),
                          }),
                        ];
                      },
                      proxy: !0,
                    },
                    {
                      key: "content",
                      fn: function () {
                        return [
                          s("AxFilesystemSearchTable", {
                            staticClass:
                              "row d-flex flex-column g-0 flex-nowrap flex-grow-1 flex-shrink-1 mh-0",
                            attrs: {
                              results: e.results,
                              query: e.query,
                              loading: e.loading,
                            },
                            on: { modified: e.onModified },
                          }),
                        ];
                      },
                      proxy: !0,
                    },
                  ],
                  null,
                  !1,
                  351630046
                ),
              }),
        ],
        1
      )
    );
  },
  ir = [],
  or = n(sr, rr, ir, !1, null, "fb4a0795", null, null);
const nr = or.exports,
  ar = dt(
    (t, e) => {
      e(t);
    },
    500,
    { maxWait: 1e3 }
  ),
  dr = o.extend({
    components: { AxInputSearch: lt, AxFilesystemSearch: nr, AxMenu: Je },
    props: { disabled: { type: Boolean, default: !1 } },
    data() {
      const t = [],
        e = new Map([
          ["name", () => !0],
          ["id", (r) => r.type === d.Shortcut],
        ]),
        s = new O(t, e);
      return {
        loading: !1,
        searchSessionStarted: !1,
        searchListOutdated: !1,
        searchList: t,
        searchEngine: s,
        searchFields: e,
        opened: !1,
      };
    },
    computed: {
      dataReloadRequired() {
        return (
          !this.loading && this.searchListOutdated && this.searchText.length > 0
        );
      },
      searchResults() {
        const { searchText: t } = this;
        return t && t.length > 0 ? this.searchEngine.doSearch(t) : [];
      },
      searchText() {
        const { fs: t } = this.$store.state;
        return t.searchData.query;
      },
      searchData() {
        const { fs: t } = this.$store.state;
        return t.searchData;
      },
      isSearching() {
        const { query: t } = this.searchData;
        return t.length > 0;
      },
    },
    watch: {
      dataReloadRequired(t) {
        t && this.getSearchTree();
      },
      searchResults(t) {
        this.$store.commit(new g({ results: t }));
      },
      "$route.query": function (t, e) {
        !t.searchQuery &&
          e.searchQuery &&
          (this.$store.commit(new g({ query: "" })),
          this.toggleSearchSessionStarted(!1));
      },
    },
    created() {
      this.$store.commit(new g({ query: "" })), this.setSearchInRoute("");
    },
    destroyed() {
      this.$store.commit(new g({ query: "" })), this.setSearchInRoute("");
    },
    methods: {
      searchQueryChanged(t) {
        ar(t, (e) => {
          this.setSearchInRoute(e), this.$store.commit(new g({ query: e }));
        });
      },
      setSearchInRoute(t) {
        let e,
          s = !1;
        const { searchQuery: r } = this.$route.query;
        if (!(t === r || (!t && !r))) {
          if (t) (s = !0), (e = { ...this.$route.query, searchQuery: t });
          else {
            const { searchQuery: i, ...a } = this.$route.query;
            i && (s = !0), (e = a);
          }
          s && this.$router.replace({ query: e });
        }
      },
      toggleFocus(t) {
        t
          ? this.searchSessionStarted || this.toggleSearchSessionStarted(!0)
          : this.searchText || this.toggleSearchSessionStarted(!1);
      },
      toggleSearchSessionStarted(t) {
        t && t !== this.searchSessionStarted && (this.searchListOutdated = !0),
          (this.searchSessionStarted = t);
      },
      async getSearchTree() {
        const e = {
          action: async () => {
            (this.loading = !0), this.$store.commit(new g({ isLoading: !0 }));
            try {
              (this.searchList = await Ge()),
                (this.searchEngine = new O(this.searchList, this.searchFields));
            } finally {
              (this.searchListOutdated = !1),
                this.$store.commit(new g({ isLoading: !1 })),
                (this.loading = !1);
            }
          },
        };
        this.$store.dispatch(new He(e));
      },
    },
  });
var ur = function () {
    var e = this,
      s = e._self._c;
    return (
      e._self._setupProxy,
      e.disabled
        ? e._e()
        : s(
            "div",
            {
              staticClass: "ax-header-search",
              class: { opened: e.opened || !!e.searchText },
            },
            [
              s(
                "AxMenu",
                {
                  attrs: {
                    value: e.opened || !!e.searchText,
                    color: "link",
                    strategy: "fixed",
                    skidding: 0,
                    distance: 10,
                    "content-class": "ax-header-search-content",
                    "control-manually": "",
                    "close-on-content-click": !1,
                  },
                  scopedSlots: e._u(
                    [
                      {
                        key: "activator",
                        fn: function () {
                          return [
                            s("AxInputSearch", {
                              staticClass: "desktop-app-no-drag",
                              attrs: {
                                "keep-placeholder": "",
                                value: e.searchText,
                              },
                              on: {
                                focus: function (r) {
                                  return e.toggleFocus(!0);
                                },
                                blur: function (r) {
                                  return e.toggleFocus(!1);
                                },
                                input: e.searchQueryChanged,
                                open: function (r) {
                                  e.opened = r;
                                },
                              },
                            }),
                          ];
                        },
                        proxy: !0,
                      },
                    ],
                    null,
                    !1,
                    734236106
                  ),
                },
                [
                  s(
                    "KeepAlive",
                    [
                      e.isSearching
                        ? s("AxFilesystemSearch", {
                            attrs: {
                              loading: e.searchData.isLoading,
                              query: e.searchData.query,
                              results: e.searchData.results,
                            },
                          })
                        : e._e(),
                    ],
                    1
                  ),
                ],
                1
              ),
            ],
            1
          )
    );
  },
  lr = [],
  cr = n(dr, ur, lr, !1, null, "489d6dc4", null, null);
const pr = cr.exports,
  mr = o.extend({
    components: { AxHeadingLogo: js, AxAccountMenu: Us, AxHeaderSearch: pr },
    computed: {
      minimized() {
        return this.$store.getters.headerMinimized;
      },
      isSubInstance() {
        const { axShareConfig: t } = this.$store.state;
        return t !== null && t.IsSubInstance;
      },
      isElectron() {
        return x;
      },
      isFullScreen() {
        const { desktop: t } = this.$store.state;
        return t.desktopParams.isFullScreen;
      },
    },
  });
var hr = function () {
    var e = this,
      s = e._self._c;
    return (
      e._self._setupProxy,
      s("Transition", { attrs: { name: "heading-slide-up" } }, [
        s(
          "div",
          {
            directives: [
              {
                name: "show",
                rawName: "v-show",
                value: !e.minimized,
                expression: "!minimized",
              },
            ],
            staticClass: "ax-heading align-items-stretch",
            class: { "desktop-app-drag": !e.isFullScreen },
          },
          [
            s(
              "div",
              { staticClass: "container-fluid d-flex align-items-stretch" },
              [
                s("div", { staticClass: "heading-container" }, [
                  s("div", { staticClass: "spread logo-and-navigation" }, [
                    s("div", { staticClass: "row flex-grow-1 flex-shrink-1" }, [
                      s("div", { staticClass: "col-12" }, [
                        s(
                          "div",
                          {
                            staticClass:
                              "d-flex h-100 flex-column justify-content-around position-relative",
                          },
                          [
                            e.isElectron
                              ? e._e()
                              : s("AxHeadingLogo", {
                                  staticClass: "heading-logo",
                                }),
                          ],
                          1
                        ),
                      ]),
                    ]),
                  ]),
                  s("div", { staticClass: "search" }, [s("AxHeaderSearch")], 1),
                  s("div", { staticClass: "spread" }, [
                    s(
                      "div",
                      { staticClass: "d-flex align-items-center" },
                      [
                        s("RouterView", { attrs: { name: "headingControls" } }),
                        s(
                          "div",
                          { staticClass: "ax-heading__end" },
                          [
                            s("AxAccountMenu", {
                              attrs: {
                                "link-classes":
                                  "header-link desktop-app-no-drag",
                              },
                            }),
                          ],
                          1
                        ),
                      ],
                      1
                    ),
                  ]),
                ]),
              ]
            ),
          ]
        ),
      ])
    );
  },
  fr = [],
  gr = n(mr, hr, fr, !1, null, "a53750a5", null, null);
const xr = gr.exports,
  S = "organizations",
  wr = { type: Object, required: !0 },
  br = o.extend({
    components: { AxPushNotificationsBase: F },
    props: { organization: wr, readonly: { type: Boolean, default: !1 } },
    data() {
      return {
        hubName: S,
        listeners: {
          leaveOrDeleteUsersFromOrganization: async (t) => {
            this.$emit("leaveOrDeleteUsersFromOrganization", t);
          },
          deleteOrganization: async (t) => {
            this.$emit("deleteOrganization", t);
          },
          renameOrganization: async (t) => {
            this.$emit("renameOrganization", t);
          },
        },
      };
    },
    async mounted() {
      this.readonly ||
        this.$nextTick(async () => {
          await A.addToGroup(S, this.organization.Id);
        });
    },
    async beforeDestroy() {
      this.readonly || (await A.removeFromGroup(S, this.organization.Id));
    },
  });
var vr = function () {
    var e = this,
      s = e._self._c;
    return (
      e._self._setupProxy,
      s("AxPushNotificationsBase", {
        attrs: { hub: e.hubName, listeners: e.listeners },
      })
    );
  },
  Ar = [],
  yr = n(br, vr, Ar, !1, null, null, null, null);
const _r = yr.exports,
  Fr = o.extend({
    components: { AxPushNotificationsOrganization: _r },
    computed: {
      organizations() {
        return Object.values(this.$store.getters.organizations);
      },
      currentUserId() {
        const { user: t } = this.$store.state;
        return t.userInfo ? t.userInfo.userId : "";
      },
    },
    methods: {
      async leaveOrDeleteUsersFromOrganization(t, e) {
        l(t.SubInstanceId, e.Id) &&
          (t.UsersIds.some((s) => s === this.currentUserId) &&
            (await this.$router.push({ name: u.home.name })),
          await this.refreshData());
      },
      async deleteOrganization(t, e) {
        l(t.SubInstanceId, e.Id) && (await this.refreshData());
      },
      async renameOrganization(t, e) {
        l(t.OrganizationId, e.Id) &&
          this.$store.commit(new Qe(t.OrganizationId, t.NewName));
      },
      async refreshData() {
        await p(1e3);
        const t = [
          this.$store.dispatch(new q()),
          this.$store.dispatch(new J()),
          this.$store.dispatch(new H()),
        ];
        await Promise.all(t);
      },
    },
  });
var Cr = function () {
    var e = this,
      s = e._self._c;
    return (
      e._self._setupProxy,
      s(
        "div",
        { staticClass: "organizations-push" },
        e._l(e.organizations, function (r) {
          return s("AxPushNotificationsOrganization", {
            key: r.Id,
            attrs: { organization: r },
            on: {
              leaveOrDeleteUsersFromOrganization: function (i) {
                return e.leaveOrDeleteUsersFromOrganization(i, r);
              },
              deleteOrganization: function (i) {
                return e.deleteOrganization(i, r);
              },
              renameOrganization: function (i) {
                return e.renameOrganization(i, r);
              },
            },
          });
        }),
        1
      )
    );
  },
  kr = [],
  Sr = n(Fr, Cr, kr, !1, null, null, null, null);
const Pr = Sr.exports,
  P = "workspaces",
  Ir = {
    type: Object,
    required: !0,
    validator(t) {
      return G(t);
    },
  },
  Ur = o.extend({
    components: { AxPushNotificationsBase: F },
    props: { workspace: Ir, readonly: { type: Boolean, default: !1 } },
    data() {
      return {
        hubName: P,
        listeners: {
          commentsChanged: (t) => {
            this.$emit("comments-changed", t);
          },
          createFolder: (t) => {
            this.$emit("create-folder", t);
          },
          renameFolder: (t) => {
            this.$emit("rename-folder", t);
          },
          createProject: (t) => {
            this.$emit("create-project", t);
          },
          deleteItems: (t) => {
            this.$emit("delete-items", t);
          },
          moveItems: (t) => {
            this.$emit("move-items", t);
          },
          artboardProjectChanged: async (t) => {
            this.$emit("artboard-project-changed", t);
          },
          rpProjectChanged: async (t) => {
            this.$emit("rp-project-changed", t);
          },
          workspaceInvitationDeleted: async (t) => {
            this.$emit("workspace-invitation-deleted", t);
          },
          workspaceInvited: async (t) => {
            this.$emit("workspace-invited", t);
          },
          workspaceRenamed: async (t) => {
            this.$emit("workspace-renamed", t);
          },
          workspaceLeave: async (t) => {
            this.$emit("workspace-leave", t);
          },
          updateAccessLevel: async (t) => {
            this.$emit("update-access-level", t);
          },
        },
      };
    },
    async mounted() {
      this.readonly ||
        this.$nextTick(async () => {
          await A.addToGroup(P, this.workspace.id);
        });
    },
    async beforeDestroy() {
      this.readonly || (await A.removeFromGroup(P, this.workspace.id));
    },
  });
var $r = function () {
    var e = this,
      s = e._self._c;
    return (
      e._self._setupProxy,
      s("AxPushNotificationsBase", {
        attrs: { hub: e.hubName, listeners: e.listeners },
      })
    );
  },
  Br = [],
  Rr = n(Ur, $r, Br, !1, null, null, null, null);
const Or = Rr.exports,
  jr = o.extend({
    components: { AxPushNotificationsWorkspace: Or },
    computed: {
      workspaces() {
        return Object.values(this.$store.getters.workspaces);
      },
      node() {
        const t = this.$store.getters.currentFolderId;
        if (t) return this.$store.getters.getNodeByFolderId(t);
      },
      currentUserId() {
        const { user: t } = this.$store.state;
        return t.userInfo ? t.userInfo.userId : "";
      },
      currentWorkspaceId() {
        const { workspaceId: t } = this.$route.params;
        return t;
      },
    },
    methods: {
      async workspaceCommentsChanged(t, e) {
        l(t.FilesystemId, e.id) &&
          (await p(1e3),
          await this.$store.dispatch(new m(e)),
          this.currentWorkspaceId === e.id &&
            this.node &&
            !G(this.node) &&
            (await this.$store.dispatch(new m(this.node))));
      },
      async workspaceRenamedEvent(t, e) {
        l(t.FilesystemId, e.id) &&
          (await p(1e3),
          this.$store.commit(new Ke(t.FilesystemId, t.NewName)),
          (!this.node || this.node.type !== d.Workspace) &&
            (await this.$store.dispatch(new m(e))));
      },
      async workspaceLeaveEvent(t, e) {
        l(t.FilesystemId, e.id) &&
          (this.currentWorkspaceId === t.FilesystemId &&
            this.currentUserId === t.UserId &&
            (await this.$router.push({ name: u.fs.name })),
          await this.$store.dispatch(new Xe(e, t.UserId, this.currentUserId)));
      },
      async createFolderEvent(t, e) {
        if (l(t.FilesystemId, e.id) && t.Folder && t.ParentFolder) {
          const s = this.$store.getters.getNodeByFolderId(
            t.ParentFolder.FolderId
          );
          if (!s) return;
          this.$store.commit(new Ye(s, t.Folder));
        }
      },
      async renameFolderEvent(t, e) {
        l(t.FilesystemId, e.id) &&
          this.node &&
          this.$store.commit(new Ze(t.FolderId, t.FolderName));
      },
      async createProjectEvent(t, e) {
        t.UserId !== this.currentUserId &&
          l(t.FilesystemId, e.id) &&
          this.node &&
          (await p(1e3), await this.$store.dispatch(new m(this.node)));
      },
      async moveOrDeleteItemsEvent(t, e) {
        if (t.UserId !== this.currentUserId && l(t.FilesystemId, e.id)) {
          const s = this.$store.getters.getNodeByFolderId(t.FolderId);
          if (!s) return;
          this.removeItems(t.Folders, s),
            this.removeItems(t.Shortcuts, s),
            this.node &&
              t.DestinationFolderId &&
              this.$route.params.id === t.DestinationFolderId &&
              (await p(1e3), await this.$store.dispatch(new m(this.node)));
        }
      },
      async projectChangeEvent(t, e) {
        t.UserId !== this.currentUserId &&
          l(t.FilesystemId, e.id) &&
          this.node &&
          this.$route.params.id === t.FolderId &&
          (await p(1e3), await this.$store.dispatch(new m(this.node)));
      },
      async workspaceInvitationDeletedEvent(t, e) {
        l(t.FilesystemId, e.id) &&
          (t.FilesystemDelete ||
            (await p(1e3), await this.$store.dispatch(new R(e.id))));
      },
      async workspaceInvitedEvent(t, e) {
        l(t.FilesystemId, e.id) &&
          (await p(1e3), await this.$store.dispatch(new R(e.id)));
      },
      async updateAccessLevelEvent(t, e) {
        t.UserId === this.currentUserId &&
          l(t.FilesystemId, e.id) &&
          this.node &&
          (await p(1e3), await this.$store.dispatch(new m(this.node)));
      },
      removeItems(t, e) {
        t.forEach((s) => {
          this.$store.commit(new et(e.id, s)), this.$store.commit(new Q(s));
        });
      },
    },
  });
var Dr = function () {
    var e = this,
      s = e._self._c;
    return (
      e._self._setupProxy,
      s(
        "div",
        { staticClass: "workspaces-push" },
        e._l(e.workspaces, function (r) {
          return s("AxPushNotificationsWorkspace", {
            key: r.id,
            attrs: { workspace: r },
            on: {
              "comments-changed": function (i) {
                return e.workspaceCommentsChanged(i, r);
              },
              "create-folder": function (i) {
                return e.createFolderEvent(i, r);
              },
              "rename-folder": function (i) {
                return e.renameFolderEvent(i, r);
              },
              "create-project": function (i) {
                return e.createProjectEvent(i, r);
              },
              "delete-items": function (i) {
                return e.moveOrDeleteItemsEvent(i, r);
              },
              "move-items": function (i) {
                return e.moveOrDeleteItemsEvent(i, r);
              },
              "artboard-project-changed": function (i) {
                return e.projectChangeEvent(i, r);
              },
              "rp-project-changed": function (i) {
                return e.projectChangeEvent(i, r);
              },
              "workspace-invitation-deleted": function (i) {
                return e.workspaceInvitationDeletedEvent(i, r);
              },
              "workspace-invited": function (i) {
                return e.workspaceInvitedEvent(i, r);
              },
              "workspace-renamed": function (i) {
                return e.workspaceRenamedEvent(i, r);
              },
              "update-access-level": function (i) {
                return e.updateAccessLevelEvent(i, r);
              },
              "workspace-leave": function (i) {
                return e.workspaceLeaveEvent(i, r);
              },
            },
          });
        }),
        1
      )
    );
  },
  Nr = [],
  Er = n(jr, Dr, Nr, !1, null, null, null, null);
const Mr = Er.exports,
  Lr = o.extend({
    components: { AxPushNotificationsBase: F },
    computed: {
      listeners() {
        return {
          workspaceInvited: async (t) => {
            await p(1e3);
            const e = [
              this.$store.dispatch(new q()),
              this.$store.dispatch(new J()),
              this.$store.dispatch(new H()),
            ];
            if ((await Promise.all(e), await K())) {
              const s = {
                authorEmail: t.OwnerEmail,
                authorName: t.OwnerName,
                body: t.MentionComment,
                tag: t.Id,
                authorProfileImage: t.OwnerProfileImage,
                onclick: async (r) => {
                  r && r.close(),
                    await this.$router.push({
                      name: u["fs.workspace.invited"].name,
                      params: { workspaceId: t.FilesystemId },
                    });
                },
              };
              await this.$store.dispatch(new tt(s));
            }
          },
          workspaceInvitationDeleted: async (t) => {
            let e = !1;
            const { shortcut: s } = this.$route.params;
            if (s) {
              const i = this.$store.getters.findWorkspace(s);
              i && i.id === t.FilesystemId && (e = !0);
            }
            this.$store.commit(new Q(t.FilesystemId)),
              (this.$router.currentRoute.path
                .toLowerCase()
                .indexOf(t.FilesystemId.toLowerCase()) >= 0 ||
                e) &&
                (await this.$router.push({ name: u.fs.name }));
          },
        };
      },
    },
  });
var Tr = function () {
    var e = this,
      s = e._self._c;
    return (
      e._self._setupProxy,
      s("AxPushNotificationsBase", {
        attrs: { hub: "notifications", listeners: e.listeners },
      })
    );
  },
  Wr = [],
  Vr = n(Lr, Tr, Wr, !1, null, null, null, null);
const zr = Vr.exports,
  qr = o.extend({
    components: { AxPushNotificationsBase: F },
    computed: {
      listeners() {
        return {
          userMentioned: async (t) => {
            await p(1e3);
            const e = t.Shortcut.toLowerCase();
            if (t.MentionType === b.PublishNote) {
              const s = this.$store.getters.findWorkspace(e);
              s && (await this.$store.dispatch(new m(s)));
            }
            if (await K()) {
              const s = {
                authorName: t.AuthorName,
                authorEmail: t.AuthorEmail,
                body: t.Message,
                tag: t.Id,
                authorProfileImage: t.AuthorProfileImage,
                onclick: async (r) => {
                  r && r.close();
                  try {
                    if (
                      t.MentionType === b.Issue ||
                      t.MentionType === b.IssueComment
                    ) {
                      if (
                        (await st()).Items.some(
                          (a) => a.ShortcutKey.toLowerCase() === e.toLowerCase()
                        )
                      ) {
                        const a = this.$store.state.axShareConfig;
                        if (a) {
                          const c = z(a, { id: e });
                          window.location.href = `${c.full}#issueCode=${t.IssueCode}&type=issue`;
                        }
                        return;
                      }
                      await this.$router.push({
                        name: u["expo.preview"].name,
                        params: { shortcut: e, screen: t.PageId },
                        query: { comment: t.IssueCode },
                      });
                    } else
                      t.MentionType === b.PublishNote &&
                        (await this.$router.push({
                          name: u["project.history"].name,
                          params: { shortcut: e },
                        }));
                  } catch (i) {
                    if (!ut.isNavigationFailure(i)) throw i;
                  }
                },
              };
              this.$store.dispatch(new rt(s));
            }
          },
        };
      },
    },
  });
var Jr = function () {
    var e = this,
      s = e._self._c;
    return (
      e._self._setupProxy,
      s("AxPushNotificationsBase", {
        attrs: { hub: "notifications", listeners: e.listeners },
      })
    );
  },
  Hr = [],
  Gr = n(qr, Jr, Hr, !1, null, null, null, null);
const Qr = Gr.exports,
  Kr = o.extend({
    components: { AxButton: w, AxIcon: f },
    computed: {
      commonErrors() {
        const { toastNotifications: t } = this.$store.state;
        return t && t.errors ? Object.values(t.errors) : [];
      },
      anyToastNotifications() {
        return this.commonErrors.length > 0;
      },
    },
    methods: {
      dismissError(t) {
        this.$store.commit(new it(t));
      },
    },
  });
var Xr = function () {
    var e = this,
      s = e._self._c;
    return (
      e._self._setupProxy,
      e.anyToastNotifications
        ? s(
            "div",
            { staticClass: "ax-toast-notifications-area" },
            e._l(e.commonErrors, function (r) {
              return s(
                "div",
                {
                  key: r.id,
                  staticClass: "ax-error-toast-notification",
                  attrs: { tabindex: "-1" },
                  on: {
                    keyup: function (i) {
                      return !i.type.indexOf("key") &&
                        e._k(i.keyCode, "esc", 27, i.key, ["Esc", "Escape"])
                        ? null
                        : e.dismissError(r.id);
                    },
                  },
                },
                [
                  s("div", {}, [
                    s("div", { staticClass: "row" }, [
                      s(
                        "div",
                        { staticClass: "col-sm-1" },
                        [
                          s("AxIcon", {
                            staticClass: "ax-toast-error-icon",
                            attrs: { name: "exclamation-circle" },
                          }),
                        ],
                        1
                      ),
                      s("div", { staticClass: "col" }, [
                        e._v(" " + e._s(r.text) + " "),
                      ]),
                      s(
                        "div",
                        { staticClass: "col-auto" },
                        [
                          s(
                            "AxButton",
                            {
                              attrs: { color: "link" },
                              on: {
                                click: function (i) {
                                  return e.dismissError(r.id);
                                },
                              },
                            },
                            [
                              s("AxIcon", {
                                attrs: { name: "add", rotate: "45deg" },
                              }),
                            ],
                            1
                          ),
                        ],
                        1
                      ),
                    ]),
                  ]),
                ]
              );
            }),
            0
          )
        : e._e()
    );
  },
  Yr = [],
  Zr = n(Kr, Xr, Yr, !1, null, "d7154078", null, null);
const ei = Zr.exports,
  ti = () =>
    _(
      () => import("./AxWorkspacesMigrationDialog-B1D44buS.js"),
      __vite__mapDeps([4, 1, 2, 3, 5, 6, 7])
    ),
  si = o.extend({
    components: { AxWorkspacesMigrationDialog: ti },
    computed: {
      allowWorkspacesMigrate() {
        return this.$store.getters.allowWorkspacesMigrate;
      },
      inProgress() {
        const { migration: t } = this.$store.state;
        return t.inProgress;
      },
      migrationId() {
        const { migration: t } = this.$store.state;
        return t.migrationId;
      },
    },
  });
var ri = function () {
    var e = this,
      s = e._self._c;
    return (
      e._self._setupProxy,
      e.allowWorkspacesMigrate && e.inProgress
        ? s("AxWorkspacesMigrationDialog", {
            attrs: { "migration-id": e.migrationId },
          })
        : e._e()
    );
  },
  ii = [],
  oi = n(si, ri, ii, !1, null, null, null, null);
const ni = oi.exports,
  ai = () =>
    _(
      () => import("./AxInstallingSketchPluginNotification-6xN0FKo3.js"),
      __vite__mapDeps([8, 1, 2, 3, 9, 10])
    ),
  di = () =>
    _(
      () => import("./AxBadgeNotifications-giH4WeDD.js"),
      __vite__mapDeps([11, 1, 2, 3])
    ),
  ui = o.extend({
    components: {
      FixedHeader: ft,
      AxHeading: xr,
      AxInstallingSketchPluginNotification: ai,
      AxToastNotifications: ei,
      AxArtboardUploads: rs,
      AxBadgeNotifications: di,
      AxPushNotificationsGlobal: zr,
      AxPushNotificationsMentioned: Qr,
      AxPushNotificationsAllWorkspaces: Mr,
      AxWorkspacesMigration: ni,
      AxPushNotificationsAllOrganizations: Pr,
    },
    data() {
      return { isElectron: x };
    },
  });
var li = function () {
    var e = this,
      s = e._self._c;
    return (
      e._self._setupProxy,
      s("FixedHeader", {
        scopedSlots: e._u([
          {
            key: "header",
            fn: function () {
              return [
                s("AxHeading"),
                s("RouterView", { attrs: { name: "projectNavigation" } }),
              ];
            },
            proxy: !0,
          },
          {
            key: "default",
            fn: function () {
              return [
                s("div", { staticClass: "container-fluid flex-grow-1" }, [
                  s("div", { staticClass: "row h-100" }, [
                    s(
                      "div",
                      { staticClass: "ax-home col-12 h-100" },
                      [
                        s(
                          "Transition",
                          {
                            attrs: { appear: "", name: "fade", mode: "out-in" },
                          },
                          [s("RouterView")],
                          1
                        ),
                      ],
                      1
                    ),
                  ]),
                ]),
                s("AxWorkspacesMigration"),
                s("AxArtboardUploads"),
                s("AxToastNotifications"),
                s("AxPushNotificationsGlobal"),
                s("AxPushNotificationsMentioned"),
                s("AxPushNotificationsAllOrganizations"),
                s("AxPushNotificationsAllWorkspaces"),
                e.isElectron
                  ? s("AxInstallingSketchPluginNotification")
                  : e._e(),
                e.isElectron ? s("AxBadgeNotifications") : e._e(),
              ];
            },
            proxy: !0,
          },
          {
            key: "footer",
            fn: function () {
              return [s("RouterView", { attrs: { name: "license" } })];
            },
            proxy: !0,
          },
        ]),
      })
    );
  },
  ci = [],
  pi = n(ui, li, ci, !1, null, null, null, null);
const mi = pi.exports,
  wi = Object.freeze(
    Object.defineProperty(
      { __proto__: null, default: mi },
      Symbol.toStringTag,
      { value: "Module" }
    )
  );
export { jt as A, wi as H };
